@synsci/thesis 0.1.0

package/src/mcp-writer.mjs

@@ -0,0 +1,441 @@
+import { access, mkdir, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { load as loadYaml, dump as dumpYaml } from "js-yaml";
+
+function stripJsonComments(text) {
+  let result = "";
+  let i = 0;
+  while (i < text.length) {
+    if (text[i] === '"') {
+      const start = i++;
+      while (i < text.length && text[i] !== '"') {
+        if (text[i] === "\\") i += 1;
+        i += 1;
+      }
+      result += text.slice(start, ++i);
+    } else if (text[i] === "/" && text[i + 1] === "/") {
+      i += 2;
+      while (i < text.length && text[i] !== "\n") i += 1;
+    } else if (text[i] === "/" && text[i + 1] === "*") {
+      i += 2;
+      while (i < text.length && !(text[i] === "*" && text[i + 1] === "/"))
+        i += 1;
+      i += 2;
+    } else {
+      result += text[i];
+      i += 1;
+    }
+  }
+  return result;
+}
+
+function normalizeLineEndings(text) {
+  return text.replace(/\r\n/g, "\n");
+}
+
+function stripTomlInlineComment(valueText) {
+  let inSingleQuotedString = false;
+  let inDoubleQuotedString = false;
+  let escapeNextChar = false;
+
+  for (let index = 0; index < valueText.length; index += 1) {
+    const char = valueText[index];
+
+    if (escapeNextChar) {
+      escapeNextChar = false;
+      continue;
+    }
+
+    if (inDoubleQuotedString && char === "\\") {
+      escapeNextChar = true;
+      continue;
+    }
+
+    if (!inDoubleQuotedString && char === "'") {
+      inSingleQuotedString = !inSingleQuotedString;
+      continue;
+    }
+
+    if (!inSingleQuotedString && char === '"') {
+      inDoubleQuotedString = !inDoubleQuotedString;
+      continue;
+    }
+
+    if (!inSingleQuotedString && !inDoubleQuotedString && char === "#") {
+      return valueText.slice(0, index).trim();
+    }
+  }
+
+  return valueText.trim();
+}
+
+function parseTomlStringValue(valueText) {
+  const stripped = stripTomlInlineComment(valueText);
+  if (!stripped) {
+    return null;
+  }
+
+  if (
+    stripped.startsWith('"""') &&
+    stripped.endsWith('"""') &&
+    stripped.length >= 6
+  ) {
+    return stripped.slice(3, -3);
+  }
+
+  if (
+    stripped.startsWith("'''") &&
+    stripped.endsWith("'''") &&
+    stripped.length >= 6
+  ) {
+    return stripped.slice(3, -3);
+  }
+
+  if (stripped.startsWith('"') && stripped.endsWith('"')) {
+    try {
+      return JSON.parse(stripped);
+    } catch {
+      return stripped.slice(1, -1);
+    }
+  }
+
+  if (stripped.startsWith("'") && stripped.endsWith("'")) {
+    return stripped.slice(1, -1);
+  }
+
+  return stripped;
+}
+
+function parseTomlSectionName(lineText) {
+  const withoutComment = stripTomlInlineComment(
+    String(lineText || "").trim(),
+  );
+  const sectionMatch = withoutComment.match(/^\[(.+)\]$/);
+  return sectionMatch ? sectionMatch[1] : null;
+}
+
+// --- JSON config ---
+
+export async function readJsonConfig(filePath) {
+  let raw;
+  try {
+    raw = await readFile(filePath, "utf8");
+  } catch {
+    return {};
+  }
+  const trimmed = raw.trim();
+  if (!trimmed) return {};
+  return JSON.parse(stripJsonComments(trimmed));
+}
+
+export async function writeJsonConfig(filePath, config) {
+  await mkdir(path.dirname(filePath), { recursive: true });
+  await writeFile(filePath, `${JSON.stringify(config, null, 2)}\n`, {
+    encoding: "utf8",
+    mode: 0o600,
+  });
+}
+
+// --- YAML config ---
+
+export async function readYamlConfig(filePath) {
+  let raw;
+  try {
+    raw = await readFile(filePath, "utf8");
+  } catch {
+    return {};
+  }
+  const trimmed = raw.trim();
+  if (!trimmed) return {};
+
+  try {
+    const parsed = loadYaml(trimmed);
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      return parsed;
+    }
+    return {};
+  } catch {
+    return {};
+  }
+}
+
+export async function writeYamlConfig(filePath, config) {
+  await mkdir(path.dirname(filePath), { recursive: true });
+  await writeFile(filePath, dumpYaml(config, { noRefs: true }), {
+    encoding: "utf8",
+    mode: 0o600,
+  });
+}
+
+// --- Path resolution ---
+
+export async function resolveMcpPath(candidates) {
+  for (const candidate of candidates) {
+    try {
+      // eslint-disable-next-line no-await-in-loop
+      await access(candidate);
+      return candidate;
+    } catch {
+      // keep searching
+    }
+  }
+  return candidates[0];
+}
+
+// --- Config section helpers ---
+
+function keyPath(configKey) {
+  return Array.isArray(configKey) ? configKey : [configKey];
+}
+
+function readConfigSection(config, configKey) {
+  const pathParts = keyPath(configKey);
+  let current = config && typeof config === "object" ? config : {};
+  for (const part of pathParts) {
+    if (
+      !current ||
+      typeof current !== "object" ||
+      Array.isArray(current) ||
+      !(part in current)
+    ) {
+      return {};
+    }
+    const next = current[part];
+    if (!next || typeof next !== "object" || Array.isArray(next)) {
+      return {};
+    }
+    current = next;
+  }
+  return current;
+}
+
+export function readNamedConfigEntry(config, configKey, serverName) {
+  const section = readConfigSection(config, configKey);
+  const entry = section[serverName];
+  if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
+    return null;
+  }
+  return entry;
+}
+
+function writeConfigSection(config, configKey, section) {
+  const pathParts = keyPath(configKey);
+  if (pathParts.length === 0) return config || {};
+
+  const root =
+    config && typeof config === "object" && !Array.isArray(config)
+      ? { ...config }
+      : {};
+  let cursor = root;
+
+  for (let index = 0; index < pathParts.length - 1; index += 1) {
+    const part = pathParts[index];
+    const existing = cursor[part];
+    cursor[part] =
+      existing && typeof existing === "object" && !Array.isArray(existing)
+        ? { ...existing }
+        : {};
+    cursor = cursor[part];
+  }
+  cursor[pathParts[pathParts.length - 1]] = section;
+  return root;
+}
+
+// --- Merge / Remove for JSON + YAML ---
+
+export function mergeServerEntry(existing, configKey, serverName, entry) {
+  const section = readConfigSection(existing, configKey);
+
+  if (serverName in section) {
+    return { config: existing, alreadyExists: true };
+  }
+
+  return {
+    config: writeConfigSection(existing, configKey, {
+      ...section,
+      [serverName]: entry,
+    }),
+    alreadyExists: false,
+  };
+}
+
+export function removeJsonServerEntry({ config, configKey, serverName }) {
+  const section = { ...readConfigSection(config, configKey) };
+
+  if (!(serverName in section)) {
+    return { config: config || {}, changed: false };
+  }
+
+  delete section[serverName];
+  return {
+    config: writeConfigSection(config, configKey, section),
+    changed: true,
+  };
+}
+
+// --- TOML read helpers ---
+
+export async function readTomlServerExists(filePath, serverName) {
+  try {
+    const raw = await readFile(filePath, "utf8");
+    return raw.includes(`[mcp_servers.${serverName}]`);
+  } catch {
+    return false;
+  }
+}
+
+export async function readTomlServerEntry(filePath, serverName) {
+  let raw = "";
+  try {
+    raw = await readFile(filePath, "utf8");
+  } catch {
+    return { exists: false, url: null };
+  }
+
+  const normalized = normalizeLineEndings(raw);
+  const lines = normalized.split("\n");
+  const targetSection = `mcp_servers.${serverName}`;
+  let inTargetSection = false;
+  let exists = false;
+  let url = null;
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+    const sectionName = parseTomlSectionName(trimmed);
+
+    if (sectionName) {
+      if (sectionName === targetSection) {
+        exists = true;
+        inTargetSection = true;
+        continue;
+      }
+
+      if (exists && !sectionName.startsWith(`${targetSection}.`)) {
+        break;
+      }
+
+      inTargetSection = false;
+      continue;
+    }
+
+    if (!inTargetSection) continue;
+
+    const withoutComment = stripTomlInlineComment(trimmed);
+    const urlMatch = withoutComment.match(/^url\s*=\s*(.+)$/);
+    if (!urlMatch) continue;
+
+    url = parseTomlStringValue(urlMatch[1]);
+  }
+
+  return { exists, url };
+}
+
+// --- TOML write helpers ---
+
+export function buildTomlServerBlock(serverName, entry) {
+  const lines = [`[mcp_servers.${serverName}]`];
+  const headers =
+    entry && typeof entry.headers === "object" && entry.headers !== null
+      ? entry.headers
+      : null;
+
+  for (const [key, value] of Object.entries(entry || {})) {
+    if (key === "headers") continue;
+    lines.push(`${key} = ${JSON.stringify(value)}`);
+  }
+
+  if (headers && Object.keys(headers).length > 0) {
+    lines.push("");
+    lines.push(`[mcp_servers.${serverName}.http_headers]`);
+    for (const [headerKey, headerValue] of Object.entries(headers)) {
+      lines.push(`${headerKey} = ${JSON.stringify(String(headerValue))}`);
+    }
+  }
+
+  return `${lines.join("\n")}\n`;
+}
+
+export async function appendTomlServer(filePath, serverName, entry) {
+  if (await readTomlServerExists(filePath, serverName)) {
+    return { alreadyExists: true };
+  }
+
+  const block = buildTomlServerBlock(serverName, entry);
+
+  let existing = "";
+  try {
+    existing = await readFile(filePath, "utf8");
+  } catch {
+    existing = "";
+  }
+
+  const separator =
+    existing.length > 0 && !existing.endsWith("\n")
+      ? "\n\n"
+      : existing.length > 0
+        ? "\n"
+        : "";
+  await mkdir(path.dirname(filePath), { recursive: true });
+  await writeFile(filePath, `${existing}${separator}${block}`, {
+    encoding: "utf8",
+    mode: 0o600,
+  });
+  return { alreadyExists: false };
+}
+
+// --- TOML removal ---
+
+function stripCodexTomlServerBlock({ tomlText, serverName }) {
+  const normalized = normalizeLineEndings(tomlText || "");
+  const lines = normalized.split("\n");
+  const output = [];
+  let skipping = false;
+  let removed = false;
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+    const sectionName = parseTomlSectionName(trimmed);
+
+    if (sectionName) {
+      const isTargetSection =
+        sectionName === `mcp_servers.${serverName}` ||
+        sectionName.startsWith(`mcp_servers.${serverName}.`);
+      if (isTargetSection) {
+        skipping = true;
+        removed = true;
+        continue;
+      }
+      if (skipping) {
+        skipping = false;
+      }
+    }
+
+    if (!skipping) {
+      output.push(line);
+    }
+  }
+
+  let stripped = output.join("\n");
+  stripped = stripped.replace(/\n{3,}/g, "\n\n").trimEnd();
+  if (stripped.length > 0) stripped += "\n";
+  return { stripped, removed };
+}
+
+export async function removeCodexTomlServer({ filePath, serverName }) {
+  let existing = "";
+  try {
+    existing = await readFile(filePath, "utf8");
+  } catch {
+    return { changed: false };
+  }
+
+  const { stripped, removed } = stripCodexTomlServerBlock({
+    tomlText: existing,
+    serverName,
+  });
+  if (!removed) return { changed: false };
+
+  await mkdir(path.dirname(filePath), { recursive: true });
+  await writeFile(filePath, stripped, { encoding: "utf8", mode: 0o600 });
+  return { changed: true };
+}