834 lines
19 KiB
JavaScript
834 lines
19 KiB
JavaScript
#!/usr/bin/env node
|
|
|
|
import fs from "node:fs";
|
|
import path from "node:path";
|
|
import { isDeepStrictEqual } from "node:util";
|
|
|
|
function usage() {
|
|
console.error(
|
|
"Usage: node install/merge-managed-mcp-config.mjs --target <config.json> --template <template.jsonc> --server-key <servers|mcpServers> [--overrides <mcp.local.jsonc>] [--set NAME=value]",
|
|
);
|
|
}
|
|
|
|
function parseArgs(argv) {
|
|
const options = {
|
|
replacements: {},
|
|
};
|
|
|
|
for (let index = 0; index < argv.length; index += 1) {
|
|
const arg = argv[index];
|
|
|
|
if (arg === "--target") {
|
|
options.target = argv[index + 1];
|
|
index += 1;
|
|
continue;
|
|
}
|
|
|
|
if (arg === "--template") {
|
|
options.template = argv[index + 1];
|
|
index += 1;
|
|
continue;
|
|
}
|
|
|
|
if (arg === "--server-key") {
|
|
options.serverKey = argv[index + 1];
|
|
index += 1;
|
|
continue;
|
|
}
|
|
|
|
if (arg === "--overrides") {
|
|
options.overrides = argv[index + 1];
|
|
index += 1;
|
|
continue;
|
|
}
|
|
|
|
if (arg === "--set") {
|
|
const assignment = argv[index + 1] ?? "";
|
|
const equalsIndex = assignment.indexOf("=");
|
|
if (equalsIndex <= 0) {
|
|
throw new Error(`Invalid --set assignment: ${assignment}`);
|
|
}
|
|
const key = assignment.slice(0, equalsIndex);
|
|
const value = assignment.slice(equalsIndex + 1);
|
|
options.replacements[key] = value;
|
|
index += 1;
|
|
continue;
|
|
}
|
|
|
|
throw new Error(`Unknown argument: ${arg}`);
|
|
}
|
|
|
|
if (!options.target || !options.template || !options.serverKey) {
|
|
usage();
|
|
throw new Error(
|
|
"--target, --template, and --server-key are all required.",
|
|
);
|
|
}
|
|
|
|
return options;
|
|
}
|
|
|
|
function stripJsonComments(input) {
|
|
let output = "";
|
|
let inString = false;
|
|
let escaping = false;
|
|
let inLineComment = false;
|
|
let inBlockComment = false;
|
|
|
|
for (let index = 0; index < input.length; index += 1) {
|
|
const char = input[index];
|
|
const next = input[index + 1];
|
|
|
|
if (inLineComment) {
|
|
if (char === "\n") {
|
|
inLineComment = false;
|
|
output += char;
|
|
}
|
|
continue;
|
|
}
|
|
|
|
if (inBlockComment) {
|
|
if (char === "*" && next === "/") {
|
|
inBlockComment = false;
|
|
index += 1;
|
|
} else if (char === "\n" || char === "\r") {
|
|
output += char;
|
|
}
|
|
continue;
|
|
}
|
|
|
|
if (inString) {
|
|
output += char;
|
|
if (escaping) {
|
|
escaping = false;
|
|
} else if (char === "\\") {
|
|
escaping = true;
|
|
} else if (char === '"') {
|
|
inString = false;
|
|
}
|
|
continue;
|
|
}
|
|
|
|
if (char === '"') {
|
|
inString = true;
|
|
output += char;
|
|
continue;
|
|
}
|
|
|
|
if (char === "/" && next === "/") {
|
|
inLineComment = true;
|
|
index += 1;
|
|
continue;
|
|
}
|
|
|
|
if (char === "/" && next === "*") {
|
|
inBlockComment = true;
|
|
index += 1;
|
|
continue;
|
|
}
|
|
|
|
output += char;
|
|
}
|
|
|
|
return output;
|
|
}
|
|
|
|
function stripTrailingCommas(input) {
|
|
let output = "";
|
|
let inString = false;
|
|
let escaping = false;
|
|
|
|
for (let index = 0; index < input.length; index += 1) {
|
|
const char = input[index];
|
|
|
|
if (inString) {
|
|
output += char;
|
|
if (escaping) {
|
|
escaping = false;
|
|
} else if (char === "\\") {
|
|
escaping = true;
|
|
} else if (char === '"') {
|
|
inString = false;
|
|
}
|
|
continue;
|
|
}
|
|
|
|
if (char === '"') {
|
|
inString = true;
|
|
output += char;
|
|
continue;
|
|
}
|
|
|
|
if (char === ",") {
|
|
let lookahead = index + 1;
|
|
while (lookahead < input.length && /\s/.test(input[lookahead])) {
|
|
lookahead += 1;
|
|
}
|
|
if (input[lookahead] === "}" || input[lookahead] === "]") {
|
|
continue;
|
|
}
|
|
}
|
|
|
|
output += char;
|
|
}
|
|
|
|
return output;
|
|
}
|
|
|
|
function renderTemplate(input, replacements) {
|
|
return input.replace(/\{\{([A-Z0-9_]+)\}\}/g, (match, key) => {
|
|
if (!(key in replacements)) {
|
|
return match;
|
|
}
|
|
return replacements[key].replace(/\\/g, "\\\\").replace(/"/g, '\\"');
|
|
});
|
|
}
|
|
|
|
function parseJsonc(input, label) {
|
|
const sanitized = stripTrailingCommas(stripJsonComments(input)).trim();
|
|
if (!sanitized) {
|
|
return {};
|
|
}
|
|
|
|
let parsed;
|
|
try {
|
|
parsed = JSON.parse(sanitized);
|
|
} catch (error) {
|
|
throw new Error(`Failed to parse ${label}: ${error.message}`);
|
|
}
|
|
|
|
if (!isPlainObject(parsed)) {
|
|
throw new Error(`${label} must contain a JSON object at the root.`);
|
|
}
|
|
|
|
return parsed;
|
|
}
|
|
|
|
function parseJsoncAst(input, label) {
|
|
if (!input.trim()) {
|
|
return {
|
|
type: "object",
|
|
start: 0,
|
|
end: 0,
|
|
properties: [],
|
|
value: {},
|
|
};
|
|
}
|
|
|
|
let index = 0;
|
|
|
|
function fail(message) {
|
|
throw new Error(`Failed to parse ${label}: ${message}`);
|
|
}
|
|
|
|
function skipTrivia() {
|
|
while (index < input.length) {
|
|
const char = input[index];
|
|
const next = input[index + 1];
|
|
|
|
if (/\s/.test(char)) {
|
|
index += 1;
|
|
continue;
|
|
}
|
|
|
|
if (char === "/" && next === "/") {
|
|
index += 2;
|
|
while (index < input.length && input[index] !== "\n") {
|
|
index += 1;
|
|
}
|
|
continue;
|
|
}
|
|
|
|
if (char === "/" && next === "*") {
|
|
index += 2;
|
|
while (
|
|
index < input.length &&
|
|
!(input[index] === "*" && input[index + 1] === "/")
|
|
) {
|
|
index += 1;
|
|
}
|
|
if (index >= input.length) {
|
|
fail("unterminated block comment");
|
|
}
|
|
index += 2;
|
|
continue;
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
function parseStringNode() {
|
|
const start = index;
|
|
index += 1;
|
|
|
|
while (index < input.length) {
|
|
const char = input[index];
|
|
|
|
if (char === "\\") {
|
|
index += 2;
|
|
continue;
|
|
}
|
|
|
|
if (char === '"') {
|
|
index += 1;
|
|
const raw = input.slice(start, index);
|
|
return {
|
|
type: "string",
|
|
start,
|
|
end: index,
|
|
value: JSON.parse(raw),
|
|
};
|
|
}
|
|
|
|
index += 1;
|
|
}
|
|
|
|
fail("unterminated string literal");
|
|
}
|
|
|
|
function parseLiteralNode(expectedText, value) {
|
|
const start = index;
|
|
if (!input.startsWith(expectedText, index)) {
|
|
fail(`expected ${expectedText}`);
|
|
}
|
|
index += expectedText.length;
|
|
return {
|
|
type: typeof value,
|
|
start,
|
|
end: index,
|
|
value,
|
|
};
|
|
}
|
|
|
|
function parseNumberNode() {
|
|
const match = /^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?/.exec(
|
|
input.slice(index),
|
|
);
|
|
if (!match) {
|
|
fail(`invalid number at offset ${index}`);
|
|
}
|
|
|
|
const start = index;
|
|
index += match[0].length;
|
|
return {
|
|
type: "number",
|
|
start,
|
|
end: index,
|
|
value: Number(match[0]),
|
|
};
|
|
}
|
|
|
|
function parseArrayNode() {
|
|
const start = index;
|
|
index += 1;
|
|
const elements = [];
|
|
|
|
skipTrivia();
|
|
while (index < input.length && input[index] !== "]") {
|
|
const valueNode = parseValueNode();
|
|
elements.push(valueNode);
|
|
skipTrivia();
|
|
|
|
if (input[index] === ",") {
|
|
index += 1;
|
|
skipTrivia();
|
|
continue;
|
|
}
|
|
|
|
if (input[index] !== "]") {
|
|
fail(`expected ',' or ']' at offset ${index}`);
|
|
}
|
|
}
|
|
|
|
if (input[index] !== "]") {
|
|
fail("unterminated array");
|
|
}
|
|
|
|
index += 1;
|
|
return {
|
|
type: "array",
|
|
start,
|
|
end: index,
|
|
elements,
|
|
value: elements.map((element) => element.value),
|
|
};
|
|
}
|
|
|
|
function parseObjectNode() {
|
|
const start = index;
|
|
index += 1;
|
|
const properties = [];
|
|
const value = {};
|
|
|
|
skipTrivia();
|
|
while (index < input.length && input[index] !== "}") {
|
|
if (input[index] !== '"') {
|
|
fail(`expected string property name at offset ${index}`);
|
|
}
|
|
|
|
const keyNode = parseStringNode();
|
|
const key = keyNode.value;
|
|
skipTrivia();
|
|
|
|
if (input[index] !== ":") {
|
|
fail(`expected ':' after property name at offset ${index}`);
|
|
}
|
|
|
|
index += 1;
|
|
skipTrivia();
|
|
|
|
const valueNode = parseValueNode();
|
|
const property = {
|
|
key,
|
|
keyNode,
|
|
value: valueNode,
|
|
hasTrailingComma: false,
|
|
};
|
|
|
|
properties.push(property);
|
|
value[key] = valueNode.value;
|
|
|
|
skipTrivia();
|
|
if (input[index] === ",") {
|
|
property.hasTrailingComma = true;
|
|
index += 1;
|
|
skipTrivia();
|
|
continue;
|
|
}
|
|
|
|
if (input[index] !== "}") {
|
|
fail(`expected ',' or '}' at offset ${index}`);
|
|
}
|
|
}
|
|
|
|
if (input[index] !== "}") {
|
|
fail("unterminated object");
|
|
}
|
|
|
|
index += 1;
|
|
return {
|
|
type: "object",
|
|
start,
|
|
end: index,
|
|
properties,
|
|
value,
|
|
};
|
|
}
|
|
|
|
function parseValueNode() {
|
|
skipTrivia();
|
|
|
|
const char = input[index];
|
|
if (char === "{") {
|
|
return parseObjectNode();
|
|
}
|
|
if (char === "[") {
|
|
return parseArrayNode();
|
|
}
|
|
if (char === '"') {
|
|
return parseStringNode();
|
|
}
|
|
if (char === "t") {
|
|
return parseLiteralNode("true", true);
|
|
}
|
|
if (char === "f") {
|
|
return parseLiteralNode("false", false);
|
|
}
|
|
if (char === "n") {
|
|
return parseLiteralNode("null", null);
|
|
}
|
|
if (char === "-" || /\d/.test(char ?? "")) {
|
|
return parseNumberNode();
|
|
}
|
|
|
|
fail(`unexpected token at offset ${index}`);
|
|
}
|
|
|
|
skipTrivia();
|
|
const root = parseValueNode();
|
|
skipTrivia();
|
|
|
|
if (index !== input.length) {
|
|
fail(`unexpected trailing content at offset ${index}`);
|
|
}
|
|
|
|
if (root.type !== "object") {
|
|
throw new Error(`${label} must contain a JSON object at the root.`);
|
|
}
|
|
|
|
return root;
|
|
}
|
|
|
|
function isPlainObject(value) {
|
|
return value !== null && typeof value === "object" && !Array.isArray(value);
|
|
}
|
|
|
|
function detectIndentUnit(input) {
|
|
const matches = input.match(/^( +|\t+)\S/m);
|
|
if (!matches) {
|
|
return " ";
|
|
}
|
|
|
|
return matches[1];
|
|
}
|
|
|
|
function detectEol(input) {
|
|
return input.includes("\r\n") ? "\r\n" : "\n";
|
|
}
|
|
|
|
function lineStartIndex(input, index) {
|
|
const newlineIndex = input.lastIndexOf("\n", index - 1);
|
|
return newlineIndex === -1 ? 0 : newlineIndex + 1;
|
|
}
|
|
|
|
function lineIndentAt(input, index) {
|
|
const start = lineStartIndex(input, index);
|
|
let end = start;
|
|
while (end < input.length && (input[end] === " " || input[end] === "\t")) {
|
|
end += 1;
|
|
}
|
|
return input.slice(start, end);
|
|
}
|
|
|
|
function renderValue(value, propertyIndent, indentUnit, eol) {
|
|
const raw = JSON.stringify(value, null, indentUnit);
|
|
if (!raw.includes("\n")) {
|
|
return raw;
|
|
}
|
|
|
|
return raw
|
|
.split("\n")
|
|
.map((line, index) => (index === 0 ? line : `${propertyIndent}${line}`))
|
|
.join(eol);
|
|
}
|
|
|
|
function renderProperty(key, value, propertyIndent, indentUnit, eol) {
|
|
return `${JSON.stringify(key)}: ${renderValue(value, propertyIndent, indentUnit, eol)}`;
|
|
}
|
|
|
|
function getObjectChildIndent(input, objectNode, indentUnit) {
|
|
if (objectNode.properties.length > 0) {
|
|
return lineIndentAt(input, objectNode.properties[0].keyNode.start);
|
|
}
|
|
|
|
return `${lineIndentAt(input, objectNode.start)}${indentUnit}`;
|
|
}
|
|
|
|
function buildMergeEdits(
|
|
input,
|
|
objectNode,
|
|
managedSettings,
|
|
indentUnit,
|
|
eol,
|
|
edits,
|
|
) {
|
|
const missingEntries = [];
|
|
|
|
for (const [key, managedValue] of Object.entries(managedSettings)) {
|
|
const property = objectNode.properties.find(
|
|
(candidate) => candidate.key === key,
|
|
);
|
|
|
|
if (!property) {
|
|
missingEntries.push([key, managedValue]);
|
|
continue;
|
|
}
|
|
|
|
if (isPlainObject(managedValue) && property.value.type === "object") {
|
|
buildMergeEdits(
|
|
input,
|
|
property.value,
|
|
managedValue,
|
|
indentUnit,
|
|
eol,
|
|
edits,
|
|
);
|
|
continue;
|
|
}
|
|
|
|
if (!isDeepStrictEqual(property.value.value, managedValue)) {
|
|
const propertyIndent = lineIndentAt(input, property.keyNode.start);
|
|
edits.push({
|
|
start: property.value.start,
|
|
end: property.value.end,
|
|
text: renderValue(managedValue, propertyIndent, indentUnit, eol),
|
|
});
|
|
}
|
|
}
|
|
|
|
if (missingEntries.length === 0) {
|
|
return;
|
|
}
|
|
|
|
const propertyIndent = getObjectChildIndent(input, objectNode, indentUnit);
|
|
const closingIndent = lineIndentAt(input, objectNode.end);
|
|
const closingBraceIndex = objectNode.end - 1;
|
|
const renderedProperties = missingEntries
|
|
.map(
|
|
([key, value]) =>
|
|
`${propertyIndent}${renderProperty(key, value, propertyIndent, indentUnit, eol)}`,
|
|
)
|
|
.join(`,${eol}`);
|
|
|
|
if (objectNode.properties.length === 0) {
|
|
edits.push({
|
|
start: objectNode.start + 1,
|
|
end: closingBraceIndex,
|
|
text: `${eol}${renderedProperties}${eol}${closingIndent}`,
|
|
});
|
|
return;
|
|
}
|
|
|
|
const lastProperty = objectNode.properties[objectNode.properties.length - 1];
|
|
if (!lastProperty.hasTrailingComma) {
|
|
edits.push({
|
|
start: lastProperty.value.end,
|
|
end: lastProperty.value.end,
|
|
text: ",",
|
|
});
|
|
}
|
|
|
|
const closingLineStart = lineStartIndex(input, objectNode.end);
|
|
const insertBeforeClosingLine = closingLineStart > lastProperty.value.end;
|
|
|
|
edits.push({
|
|
start: insertBeforeClosingLine ? closingLineStart : objectNode.end,
|
|
end: insertBeforeClosingLine ? closingLineStart : objectNode.end,
|
|
text: insertBeforeClosingLine
|
|
? `${renderedProperties}${eol}`
|
|
: `${eol}${renderedProperties}${eol}${closingIndent}`,
|
|
});
|
|
}
|
|
|
|
function buildRemovalEdits(input, objectNode, keysToRemove, edits) {
|
|
const removeSet = new Set(keysToRemove);
|
|
if (removeSet.size === 0) {
|
|
return;
|
|
}
|
|
|
|
const properties = objectNode.properties;
|
|
const closingBraceIndex = objectNode.end - 1;
|
|
|
|
for (let index = 0; index < properties.length; index += 1) {
|
|
if (!removeSet.has(properties[index].key)) {
|
|
continue;
|
|
}
|
|
|
|
let endIndex = index;
|
|
while (
|
|
endIndex + 1 < properties.length &&
|
|
removeSet.has(properties[endIndex + 1].key)
|
|
) {
|
|
endIndex += 1;
|
|
}
|
|
|
|
const firstProperty = properties[index];
|
|
const lastProperty = properties[endIndex];
|
|
const previousProperty = index > 0 ? properties[index - 1] : null;
|
|
const nextProperty =
|
|
endIndex + 1 < properties.length ? properties[endIndex + 1] : null;
|
|
|
|
if (!previousProperty && !nextProperty) {
|
|
edits.push({
|
|
start: objectNode.start + 1,
|
|
end: closingBraceIndex,
|
|
text:
|
|
closingBraceIndex > lastProperty.value.end
|
|
? input.slice(lastProperty.value.end, closingBraceIndex)
|
|
: "",
|
|
});
|
|
continue;
|
|
}
|
|
|
|
if (nextProperty) {
|
|
edits.push({
|
|
start: firstProperty.keyNode.start,
|
|
end: nextProperty.keyNode.start,
|
|
text: "",
|
|
});
|
|
index = endIndex;
|
|
continue;
|
|
}
|
|
|
|
edits.push({
|
|
start: previousProperty.value.end,
|
|
end: closingBraceIndex,
|
|
text:
|
|
closingBraceIndex > lastProperty.value.end
|
|
? input.slice(lastProperty.value.end, closingBraceIndex)
|
|
: "",
|
|
});
|
|
index = endIndex;
|
|
}
|
|
}
|
|
|
|
function applyEdits(input, edits) {
|
|
return edits
|
|
.sort((left, right) => right.start - left.start || right.end - left.end)
|
|
.reduce(
|
|
(text, edit) =>
|
|
`${text.slice(0, edit.start)}${edit.text}${text.slice(edit.end)}`,
|
|
input,
|
|
);
|
|
}
|
|
|
|
function readLocalOverrides(filePath) {
|
|
if (!filePath || !fs.existsSync(filePath)) {
|
|
return {};
|
|
}
|
|
|
|
return parseJsonc(fs.readFileSync(filePath, "utf8"), filePath);
|
|
}
|
|
|
|
function getServerOverride(overrides, name) {
|
|
const serverMap = isPlainObject(overrides.servers) ? overrides.servers : {};
|
|
const value = serverMap[name];
|
|
return isPlainObject(value) ? value : {};
|
|
}
|
|
|
|
function normalizeString(value) {
|
|
return typeof value === "string" ? value.trim() : "";
|
|
}
|
|
|
|
function buildTemplateReplacements(replacements, overrides) {
|
|
const giteaOverrides = getServerOverride(overrides, "gitea");
|
|
|
|
return {
|
|
...replacements,
|
|
GITEA_SERVER_URL: normalizeString(giteaOverrides.serverUrl),
|
|
GITEA_TOKEN: normalizeString(giteaOverrides.token),
|
|
};
|
|
}
|
|
|
|
function isServerEnabled(name, overrides) {
|
|
const serverOverride = getServerOverride(overrides, name);
|
|
if (serverOverride.enabled === false) {
|
|
return false;
|
|
}
|
|
|
|
if (name === "gitea") {
|
|
return (
|
|
serverOverride.enabled === true &&
|
|
normalizeString(serverOverride.serverUrl) !== "" &&
|
|
normalizeString(serverOverride.token) !== ""
|
|
);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
function selectManagedConfig(managedConfig, serverKey, overrides) {
|
|
const managedServers = managedConfig[serverKey];
|
|
if (!isPlainObject(managedServers)) {
|
|
throw new Error(
|
|
`${serverKey} in ${serverKey} template must be an object at the root.`,
|
|
);
|
|
}
|
|
|
|
const selectedServers = {};
|
|
for (const [name, serverConfig] of Object.entries(managedServers)) {
|
|
if (isServerEnabled(name, overrides)) {
|
|
selectedServers[name] = serverConfig;
|
|
}
|
|
}
|
|
|
|
return {
|
|
...managedConfig,
|
|
[serverKey]: selectedServers,
|
|
};
|
|
}
|
|
|
|
function removeStaleManagedServers(
|
|
input,
|
|
rootNode,
|
|
serverKey,
|
|
managedServerNames,
|
|
desiredServerNames,
|
|
) {
|
|
const serverProperty = rootNode.properties.find(
|
|
(candidate) => candidate.key === serverKey,
|
|
);
|
|
|
|
if (!serverProperty || serverProperty.value.type !== "object") {
|
|
return input;
|
|
}
|
|
|
|
const removableKeys = serverProperty.value.properties
|
|
.map((property) => property.key)
|
|
.filter(
|
|
(key) => managedServerNames.has(key) && !desiredServerNames.has(key),
|
|
);
|
|
|
|
if (removableKeys.length === 0) {
|
|
return input;
|
|
}
|
|
|
|
const edits = [];
|
|
buildRemovalEdits(input, serverProperty.value, removableKeys, edits);
|
|
return applyEdits(input, edits);
|
|
}
|
|
|
|
function main() {
|
|
const options = parseArgs(process.argv.slice(2));
|
|
const localOverrides = readLocalOverrides(options.overrides);
|
|
const replacements = buildTemplateReplacements(
|
|
options.replacements,
|
|
localOverrides,
|
|
);
|
|
|
|
const templateText = fs.readFileSync(options.template, "utf8");
|
|
const renderedTemplate = renderTemplate(templateText, replacements);
|
|
const managedConfig = parseJsonc(renderedTemplate, options.template);
|
|
const desiredConfig = selectManagedConfig(
|
|
managedConfig,
|
|
options.serverKey,
|
|
localOverrides,
|
|
);
|
|
|
|
const managedServers = desiredConfig[options.serverKey];
|
|
const allManagedServerNames = new Set(Object.keys(managedConfig[options.serverKey]));
|
|
const desiredServerNames = new Set(Object.keys(managedServers));
|
|
|
|
const existingTargetText = fs.existsSync(options.target)
|
|
? fs.readFileSync(options.target, "utf8")
|
|
: "";
|
|
const targetText = existingTargetText.trim() ? existingTargetText : "{}\n";
|
|
const targetAst = parseJsoncAst(targetText, options.target);
|
|
const cleanedTargetText = removeStaleManagedServers(
|
|
targetText,
|
|
targetAst,
|
|
options.serverKey,
|
|
allManagedServerNames,
|
|
desiredServerNames,
|
|
);
|
|
const cleanedTargetAst = parseJsoncAst(cleanedTargetText, options.target);
|
|
const indentUnit = detectIndentUnit(targetText);
|
|
const eol = detectEol(targetText);
|
|
const edits = [];
|
|
|
|
buildMergeEdits(
|
|
cleanedTargetText,
|
|
cleanedTargetAst,
|
|
desiredConfig,
|
|
indentUnit,
|
|
eol,
|
|
edits,
|
|
);
|
|
|
|
const output =
|
|
edits.length === 0 ? cleanedTargetText : applyEdits(cleanedTargetText, edits);
|
|
|
|
parseJsonc(output, options.target);
|
|
fs.mkdirSync(path.dirname(options.target), { recursive: true });
|
|
|
|
if (output === targetText) {
|
|
console.log(`Managed MCP config already up to date: ${options.target}`);
|
|
return;
|
|
}
|
|
|
|
fs.writeFileSync(options.target, output, "utf8");
|
|
console.log(`Merged managed MCP config into: ${options.target}`);
|
|
}
|
|
|
|
main(); |