@0xmonaco/mcp-server 0.5.6 → 0.5.8

package/src/tools/helpers.js

@@ -1,278 +0,0 @@
-import { OpenApiToEndpointConverter } from "@mintlify/validation";
-import dashify from "dashify";
-import fs from "node:fs";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import { OpenAPIV3 } from "openapi-types";
-import { z } from "zod";
-import { initializeObject } from "../utils";
-import { dataSchemaArrayToZod, dataSchemaToZod } from "./zod";
-export function convertStrToTitle(str) {
-	const spacedString = str.replace(/[-_]/g, " ");
-	const words = spacedString.split(/(?=[A-Z])|\s+/);
-	const titleCasedWords = words.map((word) => {
-		return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
-	});
-	return titleCasedWords.join(" ");
-}
-export function findNextIteration(set, str) {
-	let count = 1;
-	set.forEach((val) => {
-		if (val.startsWith(`${str}---`)) {
-			count = Number(val.replace(`${str}---`, ""));
-		}
-	});
-	return count + 1;
-}
-export function getMcpEnabledEndpointsFromOpenApiSpec(spec) {
-	var _a;
-	const mcpEnabledEndpoints = [];
-	const isMcpEnabledGloballyInSpec =
-		((_a = spec["x-mcp"]) === null || _a === void 0 ? void 0 : _a.enabled) ===
-		true;
-	const endpoints = getEndpointsFromOpenApi(spec);
-	if (isMcpEnabledGloballyInSpec) {
-		const notDisabledEndpoints = endpoints.filter((endpoint) => {
-			var _a;
-			return (
-				((_a = endpoint.xMcp) === null || _a === void 0
-					? void 0
-					: _a.enabled) !== false
-			);
-		});
-		mcpEnabledEndpoints.push(...notDisabledEndpoints);
-	} else {
-		const enabledEndpoints = endpoints.filter((endpoint) => {
-			var _a;
-			return (
-				((_a = endpoint.xMcp) === null || _a === void 0
-					? void 0
-					: _a.enabled) === true
-			);
-		});
-		mcpEnabledEndpoints.push(...enabledEndpoints);
-	}
-	return mcpEnabledEndpoints;
-}
-export function convertEndpointToTool(endpoint) {
-	var _a, _b;
-	let name;
-	if ((_a = endpoint.xMcp) === null || _a === void 0 ? void 0 : _a.name) {
-		name = endpoint.xMcp.name;
-	} else if (endpoint.title) {
-		name = dashify(endpoint.title);
-	} else {
-		name = convertStrToTitle(endpoint.path);
-	}
-	let description;
-	if (
-		(_b = endpoint.xMcp) === null || _b === void 0 ? void 0 : _b.description
-	) {
-		description = endpoint.xMcp.description;
-	} else if (endpoint.description) {
-		description = endpoint.description;
-	} else {
-		description = `${endpoint.method} ${endpoint.path}`;
-	}
-	return {
-		name,
-		description,
-	};
-}
-export function getMcpToolsAndEndpointsFromOpenApiSpec(spec) {
-	const endpoints = getMcpEnabledEndpointsFromOpenApiSpec(spec);
-	const toolsWithEndpoints = [];
-	endpoints.forEach((endpoint) => {
-		const tool = convertEndpointToTool(endpoint);
-		toolsWithEndpoints.push({
-			tool,
-			endpoint,
-		});
-	});
-	return toolsWithEndpoints;
-}
-export function getEndpointsFromOpenApi(specification) {
-	const endpoints = [];
-	const paths = specification.paths;
-	for (const path in paths) {
-		const pathObj = paths[path];
-		const httpMethods = Object.values(OpenAPIV3.HttpMethods);
-		for (const method of httpMethods) {
-			if (!pathObj || !(method in pathObj)) {
-				continue;
-			}
-			const endpoint = OpenApiToEndpointConverter.convert(
-				specification,
-				path,
-				method,
-				true,
-			);
-			endpoints.push(endpoint);
-		}
-	}
-	return endpoints;
-}
-export function loadEnv(key) {
-	var _a;
-	let envVars = {};
-	try {
-		const envPath = path.join(
-			fileURLToPath(import.meta.url),
-			"../../../",
-			".env.json",
-		);
-		if (fs.existsSync(envPath)) {
-			envVars = JSON.parse(fs.readFileSync(envPath).toString());
-			return (_a = envVars[key]) !== null && _a !== void 0 ? _a : {};
-		}
-	} catch (error) {
-		// if there's no env, the user will be prompted
-		// for their auth info at runtime if necessary
-		// (shouldn't happen either way)
-	}
-	return envVars;
-}
-function convertParameterSection(parameters, paramSection) {
-	Object.entries(parameters).forEach(([key, value]) => {
-		const schema = value.schema;
-		paramSection[key] = dataSchemaArrayToZod(schema);
-	});
-}
-function convertParametersAndAddToRelevantParamGroups(
-	parameters,
-	paths,
-	queries,
-	headers,
-	cookies,
-) {
-	convertParameterSection(parameters.path, paths);
-	convertParameterSection(parameters.query, queries);
-	convertParameterSection(parameters.header, headers);
-	convertParameterSection(parameters.cookie, cookies);
-}
-// this function returns all the securityParameters and seeds them with the envVariables if we have them
-export function convertSecurityParameterSection(
-	securityParameters,
-	envVariables,
-	location,
-) {
-	const res = [];
-	Object.entries(securityParameters).forEach(([key, value]) => {
-		let envKeyList = [];
-		let targetKey = "";
-		switch (value.type) {
-			case "apiKey":
-				envKeyList = [location, key];
-				targetKey = "API_KEY";
-				break;
-			case "http":
-				envKeyList = [location, key, "HTTP"];
-				targetKey = value.scheme;
-				break;
-			case "oauth2":
-			default:
-				break;
-		}
-		const target = initializeObject(
-			Object.assign({}, envVariables),
-			envKeyList,
-		);
-		if (envKeyList.length && !target[targetKey]) {
-			res.push({
-				key,
-				value: undefined,
-			});
-		} else {
-			res.push({
-				key,
-				value: target[targetKey],
-			});
-		}
-	});
-	return res;
-}
-function convertSecurityParametersAndAddToRelevantParamGroups(
-	securityParameters,
-	queries,
-	headers,
-	cookies,
-	envVariables,
-) {
-	const queryRes = convertSecurityParameterSection(
-		securityParameters.query,
-		envVariables,
-		"query",
-	);
-	const headerRes = convertSecurityParameterSection(
-		securityParameters.header,
-		envVariables,
-		"header",
-	);
-	const cookieRes = convertSecurityParameterSection(
-		securityParameters.cookie,
-		envVariables,
-		"cookie",
-	);
-	// non-intuitive that we seed the query with a zod type if it *doesn't* exist
-	// but that's because if we don't have it in our env Variables, that means the user should provide it in their query.
-	queryRes.forEach(({ key, value }) => {
-		if (!value) {
-			queries[key] = z.string();
-		}
-	});
-	headerRes.forEach(({ key, value }) => {
-		if (!value) {
-			headers[key] = z.string();
-		}
-	});
-	cookieRes.forEach(({ key, value }) => {
-		if (!value) {
-			cookies[key] = z.string();
-		}
-	});
-}
-export function convertEndpointToCategorizedZod(envKey, endpoint) {
-	var _a, _b, _c;
-	const envVariables = loadEnv(envKey);
-	const url = `${((_b = (_a = endpoint.servers) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.url) || ""}${endpoint.path}`;
-	const method = endpoint.method;
-	const paths = {};
-	const queries = {};
-	const headers = {};
-	const cookies = {};
-	let body = undefined;
-	convertParametersAndAddToRelevantParamGroups(
-		endpoint.request.parameters,
-		paths,
-		queries,
-		headers,
-		cookies,
-	);
-	if (
-		(_c = endpoint.request.security[0]) === null || _c === void 0
-			? void 0
-			: _c.parameters
-	) {
-		convertSecurityParametersAndAddToRelevantParamGroups(
-			endpoint.request.security[0].parameters,
-			queries,
-			headers,
-			cookies,
-			envVariables,
-		);
-	}
-	const jsonBodySchema = endpoint.request.body["application/json"];
-	const bodySchemaArray =
-		jsonBodySchema === null || jsonBodySchema === void 0
-			? void 0
-			: jsonBodySchema.schemaArray;
-	const bodySchema =
-		bodySchemaArray === null || bodySchemaArray === void 0
-			? void 0
-			: bodySchemaArray[0];
-	if (bodySchema) {
-		const zodBodySchema = dataSchemaToZod(bodySchema);
-		body = { body: zodBodySchema };
-	}
-	return { url, method, paths, queries, body, headers, cookies };
-}

package/src/tools/index.d.ts

@@ -1,2 +0,0 @@
-import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp";
-export declare function createTools(server: McpServer, existingTools: Set<string>): Promise<void>;

package/src/tools/index.js

@@ -1,185 +0,0 @@
-var __awaiter =
-	(this && this.__awaiter) ||
-	function (thisArg, _arguments, P, generator) {
-		function adopt(value) {
-			return value instanceof P
-				? value
-				: new P(function (resolve) {
-						resolve(value);
-					});
-		}
-		return new (P || (P = Promise))(function (resolve, reject) {
-			function fulfilled(value) {
-				try {
-					step(generator.next(value));
-				} catch (e) {
-					reject(e);
-				}
-			}
-			function rejected(value) {
-				try {
-					step(generator["throw"](value));
-				} catch (e) {
-					reject(e);
-				}
-			}
-			function step(result) {
-				result.done
-					? resolve(result.value)
-					: adopt(result.value).then(fulfilled, rejected);
-			}
-			step((generator = generator.apply(thisArg, _arguments || [])).next());
-		});
-	};
-import axios, { isAxiosError } from "axios";
-import dashify from "dashify";
-import fs from "node:fs";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import {
-	convertEndpointToCategorizedZod,
-	convertSecurityParameterSection,
-	convertStrToTitle,
-	findNextIteration,
-	loadEnv,
-} from "./helpers";
-export function createTools(server, existingTools) {
-	return __awaiter(this, void 0, void 0, function* () {
-		const toolsDir = path.join(fileURLToPath(import.meta.url), "..", "..");
-		let tools = JSON.parse(
-			fs.readFileSync(path.join(toolsDir, "tools.json"), "utf-8"),
-		);
-		tools = tools.filter((tool) => tool.endpoint);
-		tools.forEach(({ uuid, endpoint }) => {
-			const envVars = loadEnv(uuid);
-			const {
-				url: urlSchema,
-				method: methodSchema,
-				paths: pathsSchema,
-				queries: queriesSchema,
-				body: bodySchema,
-				headers: headersSchema,
-				cookies: cookiesSchema,
-			} = convertEndpointToCategorizedZod(uuid, endpoint);
-			const serverArgumentsSchemas = Object.assign(
-				Object.assign(
-					Object.assign(
-						Object.assign(Object.assign({}, pathsSchema), queriesSchema),
-						bodySchema,
-					),
-					headersSchema,
-				),
-				cookiesSchema,
-			);
-			if (!endpoint.title) {
-				endpoint.title = `${endpoint.method} ${convertStrToTitle(endpoint.path)}`;
-			}
-			if (existingTools.has(endpoint.title)) {
-				const lastCount = findNextIteration(existingTools, endpoint.title);
-				endpoint.title = `${endpoint.title}---${lastCount}`;
-			}
-			if (endpoint.title.length > 64) {
-				endpoint.title = endpoint.title.slice(0, -64);
-			}
-			existingTools.add(endpoint.title);
-			server.tool(
-				dashify(endpoint.title),
-				endpoint.description || endpoint.title,
-				serverArgumentsSchemas,
-				(inputArgs) =>
-					__awaiter(this, void 0, void 0, function* () {
-						var _a;
-						const inputParams = {};
-						const inputHeaders = {};
-						const inputCookies = {};
-						let urlWithPathParams = urlSchema;
-						let inputBody = undefined;
-						if ("body" in inputArgs) {
-							inputBody = inputArgs.body;
-							delete inputArgs.body;
-						}
-						Object.entries(inputArgs).forEach(([key, value]) => {
-							if (key in pathsSchema) {
-								urlWithPathParams = urlWithPathParams.replace(
-									`{${key}}`,
-									value,
-								);
-							} else if (key in queriesSchema) {
-								inputParams[key] = value;
-							} else if (key in headersSchema) {
-								inputHeaders[key] = value;
-							} else if (key in cookiesSchema) {
-								inputCookies[key] = value;
-							}
-						});
-						const securityParamSections =
-							(_a = endpoint.request.security[0]) === null || _a === void 0
-								? void 0
-								: _a.parameters;
-						if (securityParamSections) {
-							const headerRes = convertSecurityParameterSection(
-								securityParamSections.header,
-								envVars,
-								"header",
-							);
-							headerRes.forEach(({ key, value }) => {
-								if (value) {
-									inputHeaders[key] = value;
-								}
-							});
-							const cookieRes = convertSecurityParameterSection(
-								securityParamSections.cookie,
-								envVars,
-								"cookie",
-							);
-							cookieRes.forEach(({ key, value }) => {
-								if (value) {
-									inputCookies[key] = value;
-								}
-							});
-							const queryRes = convertSecurityParameterSection(
-								securityParamSections.query,
-								envVars,
-								"query",
-							);
-							queryRes.forEach(({ key, value }) => {
-								if (value) {
-									inputParams[key] = value;
-								}
-							});
-						}
-						try {
-							const response = yield axios({
-								url: urlWithPathParams,
-								method: methodSchema,
-								params: inputParams,
-								data: inputBody,
-								headers: inputHeaders,
-							});
-							return {
-								content: [
-									{
-										type: "text",
-										text: JSON.stringify(response.data, undefined, 2),
-									},
-								],
-							};
-						} catch (error) {
-							const errMsg = JSON.stringify(error, undefined, 2);
-							return {
-								isError: true,
-								content: [
-									{
-										type: "text",
-										text: isAxiosError(error)
-											? `${error.message}\n\n${errMsg}`
-											: errMsg,
-									},
-								],
-							};
-						}
-					}),
-			);
-		});
-	});
-}

package/src/tools/zod.d.ts

@@ -1,5 +0,0 @@
-import { DataSchema, DataSchemaArray, IncrementalDataSchema, IncrementalDataSchemaArray } from "@mintlify/validation";
-import { z } from "zod";
-type SchemaInput = DataSchema | IncrementalDataSchema;
-export declare function dataSchemaArrayToZod(schemas: DataSchemaArray | IncrementalDataSchemaArray): z.ZodTypeAny;
-export declare function dataSchemaToZod(schema: SchemaInput): z.ZodTypeAny;

package/src/tools/zod.js

@@ -1,207 +0,0 @@
-import { Blob } from "node:buffer";
-import { z } from "zod";
-function panic(error) {
-	throw error;
-}
-// WebFile polyfill implementation partly taken from the fetch-blob package:
-// https://github.com/node-fetch/fetch-blob/blob/main/file.js - MIT License
-const WebFile = class File extends Blob {
-	constructor(
-		init,
-		name = panic(new TypeError("File constructor requires name argument")),
-		options = {},
-	) {
-		if (arguments.length < 2) {
-			throw new TypeError(
-				`Failed to construct 'File': 2 arguments required, but only ${arguments.length} present.`,
-			);
-		}
-		super(init, options);
-		this._lastModified = 0;
-		this._name = "";
-		// Simulate WebIDL type casting for NaN value in lastModified option.
-		const lastModified =
-			options.lastModified === undefined
-				? Date.now()
-				: Number(options.lastModified);
-		if (!Number.isNaN(lastModified)) {
-			this._lastModified = lastModified;
-		}
-		this._name = String(name);
-	}
-	get name() {
-		return this._name;
-	}
-	get lastModified() {
-		return this._lastModified;
-	}
-	get [Symbol.toStringTag]() {
-		return "File";
-	}
-	static [Symbol.hasInstance](object) {
-		return (
-			!!object &&
-			object instanceof Blob &&
-			/^(File)$/.test(String(object[Symbol.toStringTag]))
-		);
-	}
-};
-const File = typeof global.File === "undefined" ? WebFile : global.File;
-const ANY = z.any();
-const ANY_OPT = ANY.optional();
-const BOOLEAN = z.boolean();
-const BOOLEAN_OPT = BOOLEAN.optional();
-const DATE = z.coerce.date();
-const DATE_OPT = DATE.optional();
-const FILE = z.instanceof(File);
-const FILE_OPT = FILE.optional();
-const NULL = z.null();
-const NULL_OPT = NULL.optional();
-const RECORD = z.record(z.any());
-const RECORD_WITH_DEFAULT = RECORD.default({});
-const RECORD_OPT = RECORD.optional();
-const STRING = z.string();
-const NUMBER = z.number();
-const INTEGER = z.number().int();
-export function dataSchemaArrayToZod(schemas) {
-	const firstSchema = dataSchemaToZod(schemas[0]);
-	if (!schemas[1]) {
-		return firstSchema;
-	}
-	const secondSchema = dataSchemaToZod(schemas[1]);
-	const zodSchemas = [firstSchema, secondSchema];
-	for (const schema of schemas.slice(2)) {
-		zodSchemas.push(dataSchemaToZod(schema));
-	}
-	return z.union(zodSchemas).array();
-}
-function getEnumSchema(enumList, type) {
-	const zodSchema = z.enum(enumList.map(String));
-	if (type === "string") return zodSchema;
-	return zodSchema.transform(Number);
-}
-export function dataSchemaToZod(schema) {
-	if (!("type" in schema) || Object.keys(schema).length === 0) {
-		return schema.required ? ANY : ANY_OPT;
-	}
-	switch (schema.type) {
-		case "null":
-			return schema.required ? NULL : NULL_OPT;
-		case "boolean":
-			return schema.required ? BOOLEAN : BOOLEAN_OPT;
-		case "enum<string>":
-			const strEnumSchema = getEnumSchema(schema.enum, "string");
-			return schema.required ? strEnumSchema : strEnumSchema.optional();
-		case "enum<number>":
-		case "enum<integer>":
-			const numEnumSchema = getEnumSchema(schema.enum, "number");
-			return schema.required ? numEnumSchema : numEnumSchema.optional();
-		case "file":
-			return schema.required ? FILE : FILE_OPT;
-		case "any":
-			return schema.required ? ANY : ANY_OPT;
-		case "string":
-			if ("enum" in schema && Array.isArray(schema.enum)) {
-				return schema.required
-					? z.enum(schema.enum)
-					: z.enum(schema.enum).optional();
-			}
-			if (schema.format === "binary") {
-				return schema.required ? FILE : FILE_OPT;
-			}
-			let stringSchema = STRING;
-			if (schema.minLength !== undefined) {
-				stringSchema = stringSchema.min(schema.minLength);
-			}
-			if (schema.maxLength !== undefined) {
-				stringSchema = stringSchema.max(schema.maxLength);
-			}
-			if (schema.pattern !== undefined) {
-				stringSchema = stringSchema.regex(new RegExp(schema.pattern));
-			}
-			switch (schema.format) {
-				case "email":
-					stringSchema = stringSchema.email();
-					break;
-				case "uri":
-				case "url":
-					stringSchema = stringSchema.url();
-					break;
-				case "uuid":
-					stringSchema = stringSchema.uuid();
-					break;
-				case "date-time":
-					return schema.required ? DATE : DATE_OPT;
-			}
-			return schema.required ? stringSchema : stringSchema.optional();
-		case "number":
-		case "integer":
-			if ("enum" in schema && Array.isArray(schema.enum)) {
-				const numEnumSchema = getEnumSchema(schema.enum, schema.type);
-				return schema.required ? numEnumSchema : numEnumSchema.optional();
-			}
-			let numberSchema = schema.type === "integer" ? INTEGER : NUMBER;
-			if (schema.minimum !== undefined) {
-				numberSchema = numberSchema.min(schema.minimum);
-			}
-			if (schema.maximum !== undefined) {
-				numberSchema = numberSchema.max(schema.maximum);
-			}
-			if (
-				schema.exclusiveMinimum !== undefined &&
-				schema.minimum !== undefined
-			) {
-				numberSchema = numberSchema.gt(schema.minimum);
-			}
-			if (
-				schema.exclusiveMaximum !== undefined &&
-				schema.maximum !== undefined
-			) {
-				numberSchema = numberSchema.lt(schema.maximum);
-			}
-			return schema.required ? numberSchema : numberSchema.optional();
-		case "array":
-			let itemSchema;
-			let arraySchema = z.any().array();
-			if (Array.isArray(schema.items)) {
-				itemSchema = dataSchemaArrayToZod(schema.items);
-				if (schema.items.length > 1) {
-					arraySchema = itemSchema;
-				} else {
-					arraySchema = itemSchema.array();
-				}
-			} else {
-				itemSchema = dataSchemaToZod(schema.items);
-				arraySchema = itemSchema.array();
-			}
-			if (schema.minItems !== undefined) {
-				arraySchema = arraySchema.min(schema.minItems);
-			}
-			if (schema.maxItems !== undefined) {
-				arraySchema = arraySchema.max(schema.maxItems);
-			}
-			return schema.required ? arraySchema : arraySchema.optional();
-		case "object":
-			const shape = {};
-			const requiredProperties = schema.requiredProperties;
-			const requiredPropertiesSet = new Set(
-				requiredProperties !== null && requiredProperties !== void 0
-					? requiredProperties
-					: [],
-			);
-			for (const [key, propSchema] of Object.entries(schema.properties)) {
-				const zodPropSchema = Array.isArray(propSchema)
-					? dataSchemaArrayToZod(propSchema)
-					: dataSchemaToZod(propSchema);
-				shape[key] = requiredPropertiesSet.has(key)
-					? zodPropSchema
-					: zodPropSchema.optional();
-			}
-			if (Object.keys(shape).length === 0) {
-				return schema.required ? RECORD_WITH_DEFAULT : RECORD_OPT;
-			}
-			return schema.required ? z.object(shape) : z.object(shape).optional();
-		default:
-			return ANY;
-	}
-}

package/src/tools.json

@@ -1,8 +0,0 @@
-[
-	{
-		"tool": {
-			"name": "search",
-			"description": "Search across the Mint Starter Kit documentation to fetch relevant context for a given query"
-		}
-	}
-]

package/src/utils.d.ts

@@ -1,12 +0,0 @@
-import { OpenAPI } from "@mintlify/openapi-types";
-import { AxiosResponse } from "axios";
-export type NestedRecord =
-  | string
-  | {
-      [key: string]: NestedRecord;
-    };
-export type SimpleRecord = Record<string, NestedRecord>;
-export declare function initializeObject(obj: SimpleRecord, path: string[]): SimpleRecord;
-export declare function getFileId(spec: OpenAPI.Document, index: number): string | number;
-export declare function throwOnAxiosError(response: AxiosResponse<unknown, unknown>, errMsg: string): void;
-export declare function formatErr(err: unknown): string;