@gmickel/gno 1.12.3 → 1.13.0

package/src/cli/commands/mcp/config-editors.ts

@@ -0,0 +1,432 @@
+/** Comment-preserving MCP client config readers and targeted editors. */
+
+import {
+  applyEdits,
+  type FormattingOptions,
+  getNodeValue,
+  modify,
+  type Node,
+  type ParseError,
+  parseTree,
+  printParseErrorCode,
+} from "jsonc-parser";
+
+import type { AnyMcpConfig, StandardMcpEntry } from "./config.js";
+
+import { CliError } from "../../errors.js";
+
+export interface ParsedServerEntry {
+  exists: boolean;
+  entry?: unknown;
+}
+
+export function isPlainRecord(
+  value: unknown
+): value is Record<string, unknown> {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+
+function validateRootAndServers(
+  root: unknown,
+  serversKey: string,
+  configPath: string,
+  format: string
+): Record<string, unknown> | undefined {
+  if (!isPlainRecord(root)) {
+    throw new CliError(
+      "RUNTIME",
+      `${format} root in ${configPath} must be an object.`
+    );
+  }
+  const servers = root[serversKey];
+  if (servers === undefined) {
+    return undefined;
+  }
+  if (!isPlainRecord(servers)) {
+    throw new CliError(
+      "RUNTIME",
+      `${serversKey} in ${configPath} must be an object.`
+    );
+  }
+  return servers;
+}
+
+function jsoncFormatting(content: string): FormattingOptions {
+  const indentMatch = content.match(/\n([ \t]+)\S/u)?.[1];
+  return {
+    insertSpaces: !indentMatch?.includes("\t"),
+    tabSize: indentMatch?.includes("\t") ? 1 : (indentMatch?.length ?? 2),
+    eol: content.includes("\r\n") ? "\r\n" : "\n",
+  };
+}
+
+interface ParsedJsoncDocument {
+  root: AnyMcpConfig;
+  rootNode?: Node;
+}
+
+function jsoncPropertyNodes(objectNode: Node, propertyName: string): Node[] {
+  return (objectNode.children ?? []).filter(
+    (property) =>
+      property.type === "property" &&
+      property.children?.[0]?.value === propertyName
+  );
+}
+
+function getUniqueJsoncPropertyValue(
+  objectNode: Node,
+  propertyName: string,
+  configPath: string,
+  location: string
+): Node | undefined {
+  const properties = jsoncPropertyNodes(objectNode, propertyName);
+  if (properties.length > 1) {
+    throw new CliError(
+      "RUNTIME",
+      `Ambiguous MCP JSONC config ${configPath}: duplicate "${propertyName}" key in ${location}.`
+    );
+  }
+  return properties[0]?.children?.[1];
+}
+
+function parseJsoncRoot(
+  content: string,
+  configPath: string
+): ParsedJsoncDocument {
+  if (!content.trim()) {
+    return { root: {} };
+  }
+  const errors: ParseError[] = [];
+  const rootNode = parseTree(content, errors, {
+    allowTrailingComma: true,
+    disallowComments: false,
+    allowEmptyContent: true,
+  });
+  if (errors.length > 0) {
+    const first = errors[0];
+    throw new CliError(
+      "RUNTIME",
+      `Malformed JSONC in ${configPath}: ${first ? printParseErrorCode(first.error) : "parse error"}.`
+    );
+  }
+  const root = rootNode ? getNodeValue(rootNode) : undefined;
+  if (!rootNode || rootNode.type !== "object" || !isPlainRecord(root)) {
+    throw new CliError(
+      "RUNTIME",
+      `JSONC root in ${configPath} must be an object.`
+    );
+  }
+  return { root: root as AnyMcpConfig, rootNode };
+}
+
+export function getJsoncServerEntry(
+  content: string,
+  configPath: string,
+  serversKey: string
+): ParsedServerEntry {
+  const { root, rootNode } = parseJsoncRoot(content, configPath);
+  const serversNode = rootNode
+    ? getUniqueJsoncPropertyValue(
+        rootNode,
+        serversKey,
+        configPath,
+        "the root object"
+      )
+    : undefined;
+  const servers = validateRootAndServers(root, serversKey, configPath, "JSONC");
+  if (serversNode?.type === "object") {
+    getUniqueJsoncPropertyValue(
+      serversNode,
+      "gno",
+      configPath,
+      `the "${serversKey}" server map`
+    );
+  }
+  return servers && Object.hasOwn(servers, "gno")
+    ? { exists: true, entry: servers.gno }
+    : { exists: false };
+}
+
+export function setJsoncServerEntry(
+  content: string,
+  configPath: string,
+  serversKey: string,
+  entry: unknown
+): string {
+  getJsoncServerEntry(content, configPath, serversKey);
+  const edits = modify(content, [serversKey, "gno"], entry, {
+    formattingOptions: jsoncFormatting(content),
+  });
+  const updated = applyEdits(content, edits);
+  getJsoncServerEntry(updated, configPath, serversKey);
+  return updated.endsWith("\n")
+    ? updated
+    : `${updated}${jsoncFormatting(content).eol}`;
+}
+
+export function removeJsoncServerEntry(
+  content: string,
+  configPath: string,
+  serversKey: string
+): { content: string; removed: boolean } {
+  const parsed = getJsoncServerEntry(content, configPath, serversKey);
+  if (!parsed.exists) {
+    return { content, removed: false };
+  }
+  const { root } = parseJsoncRoot(content, configPath);
+  const servers = validateRootAndServers(root, serversKey, configPath, "JSONC");
+  const path =
+    servers && Object.keys(servers).length === 1
+      ? [serversKey]
+      : [serversKey, "gno"];
+  const updated = applyEdits(
+    content,
+    modify(content, path, undefined, {
+      formattingOptions: jsoncFormatting(content),
+    })
+  );
+  getJsoncServerEntry(updated, configPath, serversKey);
+  return { content: updated, removed: true };
+}
+
+export {
+  getYamlServerEntry,
+  removeYamlServerEntry,
+  setYamlServerEntry,
+} from "./yaml-config-editor.js";
+
+const TOML_SECTION_PATTERN = /^\s*\[([^\]]+)]\s*(?:#.*)?$/;
+const TOML_GNO_SECTION_PATTERN =
+  /^\s*(?:mcp_servers|"mcp_servers"|'mcp_servers')\s*\.\s*(?:gno|"gno"|'gno')(?:\s*\.\s*(?:env|"env"|'env'))?\s*$/;
+const TOML_GNO_DESCENDANT_PATTERN =
+  /^\s*(?:mcp_servers|"mcp_servers"|'mcp_servers')\s*\.\s*(?:gno|"gno"|'gno')\s*\./;
+
+interface TomlLine {
+  text: string;
+  isTable: boolean;
+  isGnoTable: boolean;
+  isUnsupportedGnoTable: boolean;
+}
+
+function isEscaped(value: string, position: number): boolean {
+  let slashes = 0;
+  for (
+    let cursor = position - 1;
+    cursor >= 0 && value[cursor] === "\\";
+    cursor -= 1
+  ) {
+    slashes += 1;
+  }
+  return slashes % 2 === 1;
+}
+
+function nextMultilineState(
+  line: string,
+  current: '"""' | "'''" | null
+): '"""' | "'''" | null {
+  let position = 0;
+  if (current) {
+    let closing = line.indexOf(current);
+    while (closing !== -1 && current === '"""' && isEscaped(line, closing)) {
+      closing = line.indexOf(current, closing + 3);
+    }
+    if (closing === -1) {
+      return current;
+    }
+    position = closing + 3;
+  }
+
+  while (position < line.length) {
+    const character = line[position];
+    if (character === "#") {
+      return null;
+    }
+    if (character === '"') {
+      if (line.startsWith('"""', position)) {
+        let closing = line.indexOf('"""', position + 3);
+        while (closing !== -1 && isEscaped(line, closing)) {
+          closing = line.indexOf('"""', closing + 3);
+        }
+        if (closing === -1) {
+          return '"""';
+        }
+        position = closing + 3;
+        continue;
+      }
+      position += 1;
+      while (position < line.length) {
+        if (line[position] === '"' && !isEscaped(line, position)) {
+          position += 1;
+          break;
+        }
+        position += 1;
+      }
+      continue;
+    }
+    if (character === "'") {
+      if (line.startsWith("'''", position)) {
+        const closing = line.indexOf("'''", position + 3);
+        if (closing === -1) {
+          return "'''";
+        }
+        position = closing + 3;
+        continue;
+      }
+      const closing = line.indexOf("'", position + 1);
+      position = closing === -1 ? line.length : closing + 1;
+      continue;
+    }
+    position += 1;
+  }
+  return null;
+}
+
+function scanTomlLines(content: string): TomlLine[] {
+  let multiline: '"""' | "'''" | null = null;
+  return content.split(/\r?\n/).map((text) => {
+    const outside = multiline === null;
+    const section = outside ? text.match(TOML_SECTION_PATTERN)?.[1] : undefined;
+    const line: TomlLine = {
+      text,
+      isTable: section !== undefined,
+      isGnoTable:
+        section !== undefined && TOML_GNO_SECTION_PATTERN.test(section),
+      isUnsupportedGnoTable:
+        section !== undefined &&
+        TOML_GNO_DESCENDANT_PATTERN.test(section) &&
+        !TOML_GNO_SECTION_PATTERN.test(section),
+    };
+
+    multiline = nextMultilineState(text, multiline);
+    return line;
+  });
+}
+
+function parseTomlRoot(content: string, configPath: string): AnyMcpConfig {
+  if (!content.trim()) {
+    return {};
+  }
+  try {
+    const root = Bun.TOML.parse(content);
+    if (!isPlainRecord(root)) {
+      throw new Error("non-record root");
+    }
+    return root as AnyMcpConfig;
+  } catch {
+    throw new CliError("RUNTIME", `Malformed TOML in ${configPath}.`);
+  }
+}
+
+export function getTomlServerEntry(
+  content: string,
+  configPath: string
+): ParsedServerEntry {
+  const root = parseTomlRoot(content, configPath);
+  const servers = validateRootAndServers(
+    root,
+    "mcp_servers",
+    configPath,
+    "TOML"
+  );
+  return servers && Object.hasOwn(servers, "gno")
+    ? { exists: true, entry: servers.gno }
+    : { exists: false };
+}
+
+function removeTomlGnoSections(
+  content: string,
+  configPath: string
+): { content: string; removed: boolean; newline: string } {
+  const lines = scanTomlLines(content);
+  if (lines.some(({ isUnsupportedGnoTable }) => isUnsupportedGnoTable)) {
+    throw new CliError(
+      "RUNTIME",
+      `Unsupported nested GNO MCP entry in ${configPath}.`
+    );
+  }
+  const newline = content.includes("\r\n") ? "\r\n" : "\n";
+  const kept: string[] = [];
+  let removing = false;
+  let removed = false;
+  for (const line of lines) {
+    if (line.isTable) {
+      removing = line.isGnoTable;
+      removed ||= removing;
+    }
+    if (!removing || line.text.trimStart().startsWith("#")) {
+      kept.push(line.text);
+    }
+  }
+  while (kept.at(-1) === "") {
+    kept.pop();
+  }
+  return { content: kept.join(newline), removed, newline };
+}
+
+function tomlString(value: string): string {
+  return JSON.stringify(value);
+}
+
+function serializeTomlEntry(entry: StandardMcpEntry, newline: string): string {
+  const args = entry.args.map(tomlString).join(", ");
+  const lines = [
+    "[mcp_servers.gno]",
+    `command = ${tomlString(entry.command)}`,
+    `args = [${args}]`,
+  ];
+  if (entry.env && Object.keys(entry.env).length > 0) {
+    lines.push("", "[mcp_servers.gno.env]");
+    for (const key of ["GNO_DATA_DIR", "GNO_CACHE_DIR"] as const) {
+      const value = entry.env[key];
+      if (value) {
+        lines.push(`${key} = ${tomlString(value)}`);
+      }
+    }
+  }
+  return `${lines.join(newline)}${newline}`;
+}
+
+export function setTomlServerEntry(
+  content: string,
+  configPath: string,
+  entry: StandardMcpEntry
+): string {
+  const parsed = getTomlServerEntry(content, configPath);
+  const removed = removeTomlGnoSections(content, configPath);
+  if (parsed.exists && !removed.removed) {
+    throw new CliError(
+      "RUNTIME",
+      `Unsupported inline GNO MCP entry in ${configPath}.`
+    );
+  }
+  const prefix = removed.content.trimEnd();
+  const updated = prefix
+    ? `${prefix}${removed.newline}${removed.newline}${serializeTomlEntry(entry, removed.newline)}`
+    : serializeTomlEntry(entry, removed.newline);
+  parseTomlRoot(updated, configPath);
+  return updated;
+}
+
+export function removeTomlServerEntry(
+  content: string,
+  configPath: string
+): { content: string; removed: boolean } {
+  const parsed = getTomlServerEntry(content, configPath);
+  if (!parsed.exists) {
+    return { content, removed: false };
+  }
+  const result = removeTomlGnoSections(content, configPath);
+  if (!result.removed) {
+    throw new CliError(
+      "RUNTIME",
+      `Unsupported inline GNO MCP entry in ${configPath}.`
+    );
+  }
+  const updated = result.content ? `${result.content}${result.newline}` : "";
+  parseTomlRoot(updated, configPath);
+  return { content: updated, removed: true };
+}