x402-proxy 0.10.7 → 0.10.9

package/dist/dist-DxJCYyL5.js

@@ -0,0 +1,1388 @@
+#!/usr/bin/env node
+import { i as __toESM } from "./chunk-DjEMn6fM.js";
+import { t as require_dist } from "./dist-C2YO6HSQ.js";
+import { _ as string, a as array, c as discriminatedUnion, f as number, g as record, n as _enum, o as boolean, p as object, u as literal, v as union, y as unknown } from "./schemas-BxMFYNbH.js";
+import { join } from "node:path";
+import { homedir } from "node:os";
+_enum([
+	"stdio",
+	"http",
+	"streamable-http",
+	"sse"
+]);
+/**
+* Stdio transport server configuration.
+* This is the most common format — runs a local process.
+*/
+const StdioServerConfig = object({
+	command: string().min(1),
+	args: array(string()).optional().default([]),
+	env: record(string(), string()).optional().default({}),
+	transport: literal("stdio").optional().default("stdio"),
+	cwd: string().optional(),
+	timeout: number().int().positive().optional(),
+	description: string().optional()
+});
+/**
+* Remote transport server configuration.
+* Used for HTTP, Streamable HTTP, and SSE servers.
+*/
+const RemoteServerConfig = object({
+	url: string().url(),
+	transport: _enum([
+		"http",
+		"streamable-http",
+		"sse"
+	]).optional(),
+	headers: record(string(), string()).optional().default({}),
+	timeout: number().int().positive().optional(),
+	description: string().optional()
+});
+discriminatedUnion("transport", [
+	StdioServerConfig.extend({ transport: literal("stdio") }),
+	RemoteServerConfig.extend({ transport: literal("http") }),
+	RemoteServerConfig.extend({ transport: literal("streamable-http") }),
+	RemoteServerConfig.extend({ transport: literal("sse") })
+]);
+/**
+* Loose server config — accepts either stdio or remote without requiring
+* an explicit transport field. Uses the presence of `command` vs `url` to
+* determine the type.
+*/
+const LooseServerConfig = union([StdioServerConfig, RemoteServerConfig]);
+object({ mcpServers: record(string(), LooseServerConfig) });
+_enum([
+	"developer-tools",
+	"web",
+	"automation",
+	"data",
+	"search",
+	"ai",
+	"cloud",
+	"communication",
+	"design",
+	"documentation",
+	"devops",
+	"utilities",
+	"security",
+	"gaming"
+]);
+_enum([
+	"node",
+	"python",
+	"docker",
+	"binary"
+]);
+/**
+* Variables within an argument — keyed by variable name.
+*/
+const ArgumentVariableSchema = object({
+	description: string().optional(),
+	format: _enum([
+		"string",
+		"number",
+		"boolean",
+		"filepath"
+	]).optional(),
+	isRequired: boolean().optional(),
+	isSecret: boolean().optional(),
+	default: string().optional(),
+	placeholder: string().optional(),
+	value: string().optional(),
+	choices: array(string()).optional()
+});
+/**
+* A single argument definition — shared between packageArguments and runtimeArguments.
+*/
+const ArgumentSchema = object({
+	name: string().optional(),
+	description: string().optional(),
+	value: string().optional(),
+	default: string().optional(),
+	format: _enum([
+		"string",
+		"number",
+		"boolean",
+		"filepath"
+	]).optional(),
+	isRequired: boolean().optional(),
+	isSecret: boolean().optional(),
+	type: _enum(["named", "positional"]).optional(),
+	variables: record(string(), ArgumentVariableSchema).optional(),
+	isRepeated: boolean().optional(),
+	valueHint: string().optional(),
+	choices: array(string()).optional(),
+	placeholder: string().optional()
+});
+object({
+	server: object({
+		$schema: string().optional(),
+		name: string().min(1),
+		description: string(),
+		version: string().optional(),
+		title: string().optional(),
+		websiteUrl: string().optional(),
+		repository: object({
+			url: string(),
+			source: string(),
+			id: string().optional(),
+			subfolder: string().optional()
+		}).optional(),
+		icons: array(object({
+			src: string(),
+			mimeType: string().optional(),
+			sizes: union([array(string()), string()]).optional(),
+			theme: _enum(["light", "dark"]).optional()
+		})).optional(),
+		packages: array(object({
+			registryType: _enum([
+				"npm",
+				"pypi",
+				"oci",
+				"nuget",
+				"mcpb"
+			]),
+			identifier: string(),
+			version: string().optional(),
+			runtimeHint: string().optional(),
+			transport: object({
+				type: _enum([
+					"stdio",
+					"streamable-http",
+					"sse"
+				]),
+				url: string().optional()
+			}),
+			packageArguments: array(ArgumentSchema).optional(),
+			runtimeArguments: array(ArgumentSchema).optional(),
+			environmentVariables: array(object({
+				name: string(),
+				description: string().optional(),
+				value: string().optional(),
+				default: string().optional(),
+				format: _enum([
+					"string",
+					"number",
+					"boolean",
+					"filepath"
+				]).optional(),
+				isRequired: boolean().optional(),
+				isSecret: boolean().optional()
+			})).optional()
+		})).optional(),
+		remotes: array(object({
+			type: _enum(["streamable-http", "sse"]),
+			url: string(),
+			headers: array(object({
+				name: string(),
+				description: string().optional(),
+				value: string().optional(),
+				default: string().optional(),
+				format: _enum([
+					"string",
+					"number",
+					"boolean",
+					"filepath"
+				]).optional(),
+				isRequired: boolean().optional(),
+				isSecret: boolean().optional()
+			})).optional(),
+			variables: record(string(), object({
+				description: string().optional(),
+				format: string().optional(),
+				default: string().optional()
+			})).optional()
+		})).optional(),
+		_meta: record(string(), unknown()).optional()
+	}),
+	_meta: record(string(), unknown()).optional().default({})
+});
+const AppId = _enum([
+	"claude-desktop",
+	"claude-code",
+	"vscode",
+	"cursor",
+	"cline",
+	"roo-code",
+	"goose",
+	"windsurf",
+	"opencode",
+	"zed",
+	"pycharm",
+	"codex",
+	"gemini-cli",
+	"continue",
+	"amazon-q",
+	"trae",
+	"bolt-ai",
+	"libre-chat",
+	"antigravity"
+]);
+/**
+* Authentication method for private registries.
+*/
+const RegistryAuthMethod = _enum([
+	"bearer",
+	"basic",
+	"header"
+]);
+/**
+* A registry source definition.
+* Describes where to fetch MCP server definitions from.
+*/
+const RegistrySource = object({
+	name: string().min(1).regex(/^[a-z0-9-]+$/),
+	url: string().url(),
+	type: _enum(["public", "private"]).default("public"),
+	priority: number().int().nonnegative().default(100)
+});
+object({
+	method: RegistryAuthMethod,
+	token: string().optional(),
+	username: string().optional(),
+	headerName: string().optional()
+});
+/**
+* Per-server entry in a project manifest.
+* Allows overriding env vars and specifying app targets.
+*/
+const ManifestServerEntry = object({
+	env: record(string(), string()).optional(),
+	apps: array(AppId).optional(),
+	scope: _enum(["project", "global"]).optional(),
+	registry: string().optional()
+});
+object({
+	servers: record(string(), ManifestServerEntry.or(object({}))),
+	registries: array(RegistrySource).optional()
+});
+//#endregion
+//#region node_modules/.pnpm/@getmcp+core@0.10.1/node_modules/@getmcp/core/dist/utils.js
+/**
+* Utility functions for working with canonical MCP server configs.
+*/
+/**
+* Type guard: checks if a config is a stdio transport config.
+*/
+function isStdioConfig(config) {
+	return "command" in config && typeof config.command === "string";
+}
+/**
+* Type guard: checks if a config is a remote transport config.
+*/
+function isRemoteConfig(config) {
+	return "url" in config && typeof config.url === "string";
+}
+/**
+* Infer the transport type from a server config.
+*
+* For stdio configs, always returns "stdio".
+* For remote configs, uses the explicit `transport` field if set,
+* otherwise infers from the URL (paths containing "/sse" → "sse", else "http").
+*/
+function inferTransport(config) {
+	if (isStdioConfig(config)) return "stdio";
+	if (isRemoteConfig(config)) {
+		if (config.transport) return config.transport;
+		try {
+			const url = new URL(config.url);
+			if (/\/sse(\/|\?|&|$)/.test(url.pathname)) return "sse";
+		} catch {}
+		return "http";
+	}
+	return "stdio";
+}
+//#endregion
+//#region node_modules/.pnpm/@getmcp+generators@0.10.1/node_modules/@getmcp/generators/dist/base.js
+/**
+* Base class for config generators.
+* Provides common functionality for all app-specific generators.
+*/
+let _existsSync = () => false;
+try {
+	const fs = process.getBuiltinModule?.("node:fs");
+	if (fs) _existsSync = fs.existsSync;
+} catch {}
+const home = homedir();
+const configHome = process.env.XDG_CONFIG_HOME?.trim() || join(home, ".config");
+const appData = process.env.APPDATA?.trim() || join(home, "AppData", "Roaming");
+process.env.LOCALAPPDATA?.trim() || join(home, "AppData", "Local");
+const claudeHome = process.env.CLAUDE_CONFIG_DIR?.trim() || join(home, ".claude");
+const codexHome = process.env.CODEX_HOME?.trim() || join(home, ".codex");
+const INVALID_CONFIG_ERROR = "Invalid config: must have either 'command' or 'url'";
+var BaseGenerator = class {
+	/** Root key for the generated config object. Override in subclasses. */
+	rootKey = "mcpServers";
+	/**
+	* Transform a stdio config into the app-specific format.
+	* Override in subclasses to customize field mappings.
+	*/
+	transformStdio(config) {
+		return toStdioFields(config);
+	}
+	/**
+	* Transform a remote config into the app-specific format.
+	* Override in subclasses to customize field mappings.
+	*/
+	transformRemote(config) {
+		return toRemoteFields(config);
+	}
+	generate(serverName, config) {
+		let serverConfig;
+		if (isStdioConfig(config)) serverConfig = this.transformStdio(config);
+		else if (isRemoteConfig(config)) serverConfig = this.transformRemote(config);
+		else throw new Error(INVALID_CONFIG_ERROR);
+		return { [this.rootKey]: { [serverName]: serverConfig } };
+	}
+	generateAll(servers) {
+		let merged = {};
+		for (const [name, config] of Object.entries(servers)) {
+			const single = this.generate(name, config);
+			merged = deepMerge(merged, single);
+		}
+		return merged;
+	}
+	serialize(config) {
+		return JSON.stringify(config, null, 2);
+	}
+	detectInstalled() {
+		return false;
+	}
+};
+/**
+* Deep merge two objects. Arrays are replaced, not merged.
+*/
+const UNSAFE_KEYS = new Set([
+	"__proto__",
+	"constructor",
+	"prototype"
+]);
+function deepMerge(target, source) {
+	const result = { ...target };
+	for (const key of Object.keys(source)) {
+		if (UNSAFE_KEYS.has(key)) continue;
+		const targetVal = target[key];
+		const sourceVal = source[key];
+		if (isPlainObject(targetVal) && isPlainObject(sourceVal)) result[key] = deepMerge(targetVal, sourceVal);
+		else result[key] = sourceVal;
+	}
+	return result;
+}
+function isPlainObject(val) {
+	return typeof val === "object" && val !== null && !Array.isArray(val);
+}
+/**
+* Extract a clean stdio config from a LooseServerConfig.
+* Strips transport field and undefined values.
+*/
+function toStdioFields(config) {
+	if (!("command" in config)) throw new Error("Expected stdio config but got remote config");
+	const result = { command: config.command };
+	if (config.args && config.args.length > 0) result.args = config.args;
+	if (config.env && Object.keys(config.env).length > 0) result.env = config.env;
+	if (config.cwd) result.cwd = config.cwd;
+	if (config.timeout) result.timeout = config.timeout;
+	if (config.description) result.description = config.description;
+	return result;
+}
+/**
+* Extract a clean remote config from a LooseServerConfig.
+* Strips undefined values.
+*/
+function toRemoteFields(config) {
+	if (!("url" in config)) throw new Error("Expected remote config but got stdio config");
+	const result = { url: config.url };
+	if (config.transport) result.transport = config.transport;
+	if (config.headers && Object.keys(config.headers).length > 0) result.headers = config.headers;
+	if (config.timeout) result.timeout = config.timeout;
+	if (config.description) result.description = config.description;
+	return result;
+}
+//#endregion
+//#region node_modules/.pnpm/@getmcp+generators@0.10.1/node_modules/@getmcp/generators/dist/claude-desktop.js
+/**
+* Claude Desktop config generator.
+*
+* Config file: ~/Library/Application Support/Claude/claude_desktop_config.json (macOS)
+*              %AppData%\Claude\claude_desktop_config.json (Windows)
+* Format:      { "mcpServers": { "name": { "command", "args", "env" } } }
+*
+* This is essentially a passthrough — the canonical format IS the Claude Desktop format.
+*/
+var ClaudeDesktopGenerator = class extends BaseGenerator {
+	app = {
+		id: "claude-desktop",
+		name: "Claude Desktop",
+		description: "Anthropic's Claude desktop application",
+		configPaths: null,
+		globalConfigPaths: {
+			darwin: "~/Library/Application Support/Claude/claude_desktop_config.json",
+			win32: "%AppData%\\Claude\\claude_desktop_config.json",
+			linux: "~/.config/Claude/claude_desktop_config.json"
+		},
+		configFormat: "json",
+		docsUrl: "https://modelcontextprotocol.io/quickstart/user",
+		requiresRestart: true
+	};
+	detectInstalled() {
+		switch (process.platform) {
+			case "darwin": return _existsSync(join(home, "Library", "Application Support", "Claude"));
+			case "win32": return _existsSync(join(appData, "Claude"));
+			default: return _existsSync(join(configHome, "Claude"));
+		}
+	}
+};
+//#endregion
+//#region node_modules/.pnpm/@getmcp+generators@0.10.1/node_modules/@getmcp/generators/dist/claude-code.js
+/**
+* Claude Code (CLI) config generator.
+*
+* Config file: .mcp.json (project scope) or ~/.claude.json (user scope)
+* Format:      { "mcpServers": { "name": { "command", "args", "env" } } }
+* CLI:         claude mcp add <name> -- <command> [args]
+*
+* Supports stdio, http, sse transports.
+* Supports ${VAR} and ${VAR:-default} env variable syntax.
+*
+* Very similar to Claude Desktop — essentially a passthrough with
+* optional transport type for remote servers.
+*/
+var ClaudeCodeGenerator = class extends BaseGenerator {
+	app = {
+		id: "claude-code",
+		name: "Claude Code",
+		description: "Anthropic's CLI-based coding agent",
+		configPaths: ".mcp.json",
+		globalConfigPaths: {
+			darwin: "~/.claude.json",
+			win32: "%UserProfile%\\.claude.json",
+			linux: "~/.claude.json"
+		},
+		configFormat: "json",
+		docsUrl: "https://docs.anthropic.com/en/docs/claude-code/mcp"
+	};
+	transformRemote(config) {
+		const fields = toRemoteFields(config);
+		if ("transport" in config && config.transport) {
+			fields.type = config.transport;
+			delete fields.transport;
+		}
+		return fields;
+	}
+	detectInstalled() {
+		return _existsSync(claudeHome);
+	}
+};
+//#endregion
+//#region node_modules/.pnpm/@getmcp+generators@0.10.1/node_modules/@getmcp/generators/dist/vscode.js
+/**
+* VS Code / GitHub Copilot config generator.
+*
+* Config file: .vscode/mcp.json (workspace) or user-level mcp.json
+* Format:      { "servers": { "name": { "type": "stdio", "command", "args", "env" } } }
+*
+* Key differences from canonical:
+*   - Root key: "servers" (NOT "mcpServers")
+*   - Requires explicit "type" field on every server ("stdio", "http", "sse")
+*   - Supports "inputs" array for sensitive data prompting
+*   - Supports "envFile" for .env loading
+*/
+var VSCodeGenerator = class extends BaseGenerator {
+	rootKey = "servers";
+	app = {
+		id: "vscode",
+		name: "VS Code / GitHub Copilot",
+		description: "Visual Studio Code with GitHub Copilot MCP integration",
+		configPaths: ".vscode/mcp.json",
+		globalConfigPaths: null,
+		configFormat: "json",
+		docsUrl: "https://code.visualstudio.com/docs/copilot/chat/mcp-servers"
+	};
+	transformStdio(config) {
+		return {
+			type: "stdio",
+			...toStdioFields(config)
+		};
+	}
+	transformRemote(config) {
+		const transport = inferTransport(config);
+		const fields = toRemoteFields(config);
+		delete fields.transport;
+		return {
+			type: transport === "streamable-http" ? "http" : transport,
+			...fields
+		};
+	}
+	detectInstalled() {
+		switch (process.platform) {
+			case "darwin": return _existsSync(join(home, "Library", "Application Support", "Code"));
+			case "win32": return _existsSync(join(appData, "Code"));
+			default: return _existsSync(join(configHome, "Code"));
+		}
+	}
+};
+//#endregion
+//#region node_modules/.pnpm/@getmcp+generators@0.10.1/node_modules/@getmcp/generators/dist/cursor.js
+/**
+* Cursor config generator.
+*
+* Config file: .cursor/mcp.json (project) or global settings
+* Format:      { "mcpServers": { "name": { "command", "args", "env" } } }
+*
+* Very similar to Claude Desktop — essentially a passthrough.
+* Supports stdio and SSE transports.
+*/
+var CursorGenerator = class extends BaseGenerator {
+	app = {
+		id: "cursor",
+		name: "Cursor",
+		description: "Cursor AI-powered code editor",
+		configPaths: ".cursor/mcp.json",
+		globalConfigPaths: {
+			darwin: "~/.cursor/mcp.json",
+			win32: "%UserProfile%\\.cursor\\mcp.json",
+			linux: "~/.cursor/mcp.json"
+		},
+		configFormat: "json",
+		docsUrl: "https://docs.cursor.com/context/model-context-protocol",
+		requiresRestart: true
+	};
+	detectInstalled() {
+		return _existsSync(join(home, ".cursor"));
+	}
+};
+//#endregion
+//#region node_modules/.pnpm/@getmcp+generators@0.10.1/node_modules/@getmcp/generators/dist/cline.js
+/**
+* Cline config generator.
+*
+* Config file: cline_mcp_settings.json
+* Format:      { "mcpServers": { "name": { "command", "args", "env", "alwaysAllow", "disabled" } } }
+*
+* Key differences from canonical:
+*   - Extra fields: "alwaysAllow" (string array), "disabled" (boolean)
+*   - SSE servers use "url" + "headers" instead of "command"/"args"
+*/
+var ClineGenerator = class extends BaseGenerator {
+	app = {
+		id: "cline",
+		name: "Cline",
+		description: "AI coding assistant VS Code extension",
+		configPaths: null,
+		globalConfigPaths: {
+			darwin: "~/Library/Application Support/Code/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json",
+			win32: "%AppData%\\Code\\User\\globalStorage\\saoudrizwan.claude-dev\\settings\\cline_mcp_settings.json",
+			linux: "~/.config/Code/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json"
+		},
+		configFormat: "json",
+		docsUrl: "https://docs.cline.bot/mcp-servers/configuring-mcp-servers"
+	};
+	transformStdio(config) {
+		return {
+			...toStdioFields(config),
+			alwaysAllow: [],
+			disabled: false
+		};
+	}
+	transformRemote(config) {
+		return {
+			...toRemoteFields(config),
+			alwaysAllow: [],
+			disabled: false
+		};
+	}
+	detectInstalled() {
+		const extId = "saoudrizwan.claude-dev";
+		switch (process.platform) {
+			case "darwin": return _existsSync(join(home, "Library", "Application Support", "Code", "User", "globalStorage", extId));
+			case "win32": return _existsSync(join(appData, "Code", "User", "globalStorage", extId));
+			default: return _existsSync(join(configHome, "Code", "User", "globalStorage", extId));
+		}
+	}
+};
+//#endregion
+//#region node_modules/.pnpm/@getmcp+generators@0.10.1/node_modules/@getmcp/generators/dist/roo-code.js
+/**
+* Roo Code config generator.
+*
+* Config file: mcp_settings.json (global) or .roo/mcp.json (project)
+* Format:      { "mcpServers": { "name": { "command", "args", "env", ... } } }
+*
+* Key differences from canonical:
+*   - Extra fields: "alwaysAllow", "disabled", "timeout", "watchPaths",
+*     "disabledTools", "cwd"
+*   - Remote servers need explicit "type": "streamable-http" or "type": "sse"
+*   - Supports ${env:VARIABLE_NAME} syntax in args
+*   - Windows requires "cmd /c npx" wrapper
+*/
+var RooCodeGenerator = class extends BaseGenerator {
+	app = {
+		id: "roo-code",
+		name: "Roo Code",
+		description: "AI coding assistant VS Code extension (formerly Roo Cline)",
+		configPaths: null,
+		globalConfigPaths: {
+			darwin: "~/Library/Application Support/Code/User/globalStorage/rooveterinaryinc.roo-cline/settings/mcp_settings.json",
+			win32: "%AppData%\\Code\\User\\globalStorage\\rooveterinaryinc.roo-cline\\settings\\mcp_settings.json",
+			linux: "~/.config/Code/User/globalStorage/rooveterinaryinc.roo-cline/settings/mcp_settings.json"
+		},
+		configFormat: "json",
+		docsUrl: "https://docs.roocode.com/features/mcp/using-mcp-in-roo"
+	};
+	transformStdio(config) {
+		return {
+			...toStdioFields(config),
+			alwaysAllow: [],
+			disabled: false
+		};
+	}
+	transformRemote(config) {
+		const base = toRemoteFields(config);
+		const transport = inferTransport(config);
+		const { transport: _transport, description: _description, ...rest } = base;
+		return {
+			type: transport === "http" ? "streamable-http" : transport,
+			...rest,
+			alwaysAllow: [],
+			disabled: false
+		};
+	}
+	detectInstalled() {
+		const extId = "rooveterinaryinc.roo-cline";
+		switch (process.platform) {
+			case "darwin": return _existsSync(join(home, "Library", "Application Support", "Code", "User", "globalStorage", extId));
+			case "win32": return _existsSync(join(appData, "Code", "User", "globalStorage", extId));
+			default: return _existsSync(join(configHome, "Code", "User", "globalStorage", extId));
+		}
+	}
+};
+//#endregion
+//#region node_modules/.pnpm/@getmcp+generators@0.10.1/node_modules/@getmcp/generators/dist/goose.js
+/**
+* Goose config generator.
+*
+* Config file: ~/.config/goose/config.yaml (YAML!)
+* Format:
+*   extensions:
+*     name:
+*       name: Display Name
+*       cmd: npx
+*       args: [-y, @package/name]
+*       enabled: true
+*       envs: { "KEY": "value" }
+*       type: stdio
+*       timeout: 300
+*
+* Key differences from canonical:
+*   - YAML format (not JSON)
+*   - Root key: "extensions" (not "mcpServers")
+*   - "cmd" (not "command")
+*   - "envs" (not "env")
+*   - Extra fields: "enabled", "timeout" (in seconds), "name" (display name)
+*/
+var import_dist = /* @__PURE__ */ __toESM(require_dist(), 1);
+var GooseGenerator = class extends BaseGenerator {
+	app = {
+		id: "goose",
+		name: "Goose",
+		description: "Block's autonomous AI coding agent",
+		configPaths: null,
+		globalConfigPaths: {
+			darwin: "~/.config/goose/config.yaml",
+			win32: "%AppData%\\goose\\config.yaml",
+			linux: "~/.config/goose/config.yaml"
+		},
+		configFormat: "yaml",
+		docsUrl: "https://block.github.io/goose/docs/getting-started/using-extensions"
+	};
+	generate(serverName, config) {
+		let extensionConfig;
+		if (isStdioConfig(config)) extensionConfig = {
+			name: serverName,
+			cmd: config.command,
+			...config.args && config.args.length > 0 ? { args: config.args } : {},
+			enabled: true,
+			...config.env && Object.keys(config.env).length > 0 ? { envs: config.env } : {},
+			type: "stdio",
+			...config.timeout ? { timeout: Math.ceil(config.timeout / 1e3) } : {},
+			...config.description ? { description: config.description } : {}
+		};
+		else if (isRemoteConfig(config)) {
+			const transport = inferTransport(config);
+			extensionConfig = {
+				name: serverName,
+				uri: config.url,
+				enabled: true,
+				...config.headers && Object.keys(config.headers).length > 0 ? { headers: config.headers } : {},
+				type: transport,
+				...config.timeout ? { timeout: Math.ceil(config.timeout / 1e3) } : {},
+				...config.description ? { description: config.description } : {}
+			};
+		} else throw new Error(INVALID_CONFIG_ERROR);
+		return { extensions: { [serverName]: extensionConfig } };
+	}
+	/**
+	* Serialize to YAML format using the `yaml` library.
+	*/
+	serialize(config) {
+		return import_dist.stringify(config, { indent: 2 });
+	}
+	detectInstalled() {
+		return _existsSync(join(configHome, "goose")) || _existsSync(join(appData, "goose"));
+	}
+};
+//#endregion
+//#region node_modules/.pnpm/@getmcp+generators@0.10.1/node_modules/@getmcp/generators/dist/windsurf.js
+/**
+* Windsurf config generator.
+*
+* Config file: ~/.codeium/windsurf/mcp_config.json
+* Format:      { "mcpServers": { "name": { "command", "args", "env" } } }
+*
+* Key differences from canonical:
+*   - Remote HTTP servers use "serverUrl" (not "url")
+*   - Supports ${env:VARIABLE_NAME} interpolation
+*   - Has MCP Marketplace and admin whitelist controls
+*   - Very similar to Claude Desktop for stdio
+*/
+var WindsurfGenerator = class extends BaseGenerator {
+	app = {
+		id: "windsurf",
+		name: "Windsurf",
+		description: "Codeium's AI-powered code editor",
+		configPaths: null,
+		globalConfigPaths: {
+			darwin: "~/.codeium/windsurf/mcp_config.json",
+			win32: "%UserProfile%\\.codeium\\windsurf\\mcp_config.json",
+			linux: "~/.codeium/windsurf/mcp_config.json"
+		},
+		configFormat: "json",
+		docsUrl: "https://docs.windsurf.com/windsurf/cascade/mcp",
+		requiresRestart: true
+	};
+	transformRemote(config) {
+		const { url, transport: _transport, ...rest } = toRemoteFields(config);
+		return {
+			serverUrl: url,
+			...rest
+		};
+	}
+	detectInstalled() {
+		return _existsSync(join(home, ".codeium", "windsurf"));
+	}
+};
+//#endregion
+//#region node_modules/.pnpm/@getmcp+generators@0.10.1/node_modules/@getmcp/generators/dist/opencode.js
+/**
+* OpenCode config generator.
+*
+* Config file: opencode.json / opencode.jsonc
+* Format:
+*   {
+*     "$schema": "https://opencode.ai/config.json",
+*     "mcp": {
+*       "name": {
+*         "type": "local",
+*         "command": ["npx", "-y", "package"],
+*         "environment": { "KEY": "value" },
+*         "enabled": true,
+*         "timeout": 5000
+*       }
+*     }
+*   }
+*
+* Key differences from canonical:
+*   - Root key: "mcp" (not "mcpServers")
+*   - "command" is an ARRAY that merges command + args
+*   - "environment" (not "env")
+*   - Requires explicit "type": "local" | "remote"
+*   - Has "enabled" field
+*   - Env var syntax: {env:VAR} (no $ prefix)
+*/
+var OpenCodeGenerator = class extends BaseGenerator {
+	app = {
+		id: "opencode",
+		name: "OpenCode",
+		description: "Open-source AI coding agent by Anomaly",
+		configPaths: "opencode.json",
+		globalConfigPaths: null,
+		configFormat: "jsonc",
+		docsUrl: "https://opencode.ai/docs/mcp-servers/"
+	};
+	generate(serverName, config) {
+		let serverConfig;
+		if (isStdioConfig(config)) {
+			const commandArray = [config.command];
+			if (config.args && config.args.length > 0) commandArray.push(...config.args);
+			serverConfig = {
+				type: "local",
+				command: commandArray,
+				enabled: true,
+				...config.env && Object.keys(config.env).length > 0 ? { environment: config.env } : {},
+				...config.timeout ? { timeout: config.timeout } : {},
+				...config.description ? { description: config.description } : {}
+			};
+		} else if (isRemoteConfig(config)) serverConfig = {
+			type: "remote",
+			url: config.url,
+			enabled: true,
+			...config.headers && Object.keys(config.headers).length > 0 ? { headers: config.headers } : {},
+			...config.timeout ? { timeout: config.timeout } : {},
+			...config.description ? { description: config.description } : {}
+		};
+		else throw new Error(INVALID_CONFIG_ERROR);
+		return { mcp: { [serverName]: serverConfig } };
+	}
+	generateAll(servers) {
+		const mcp = {};
+		for (const [name, config] of Object.entries(servers)) {
+			const mcpSection = this.generate(name, config).mcp;
+			Object.assign(mcp, mcpSection);
+		}
+		return {
+			$schema: "https://opencode.ai/config.json",
+			mcp
+		};
+	}
+	detectInstalled() {
+		return _existsSync(join(configHome, "opencode"));
+	}
+};
+//#endregion
+//#region node_modules/.pnpm/@getmcp+generators@0.10.1/node_modules/@getmcp/generators/dist/zed.js
+/**
+* Zed config generator.
+*
+* Config file: settings.json (Zed settings)
+* Format:
+*   {
+*     "context_servers": {
+*       "name": {
+*         "command": "...",
+*         "args": ["..."],
+*         "env": {}
+*       }
+*     }
+*   }
+*
+* Key differences from canonical:
+*   - Root key: "context_servers" (not "mcpServers")
+*   - Otherwise uses standard command/args/env structure
+*   - Remote servers use "url" + "headers"
+*   - Also installable via Zed extensions
+*/
+var ZedGenerator = class extends BaseGenerator {
+	rootKey = "context_servers";
+	app = {
+		id: "zed",
+		name: "Zed",
+		description: "High-performance code editor by Zed Industries",
+		configPaths: null,
+		globalConfigPaths: {
+			darwin: "~/.config/zed/settings.json",
+			win32: "%AppData%\\Zed\\settings.json",
+			linux: "~/.config/zed/settings.json"
+		},
+		configFormat: "json",
+		docsUrl: "https://zed.dev/docs/ai/mcp"
+	};
+	transformStdio(config) {
+		return toStdioFields(config);
+	}
+	transformRemote(config) {
+		if (!("url" in config)) throw new Error("Expected remote config but got stdio config");
+		return {
+			url: config.url,
+			...config.headers && Object.keys(config.headers).length > 0 ? { headers: config.headers } : {},
+			...config.timeout ? { timeout: config.timeout } : {}
+		};
+	}
+	detectInstalled() {
+		switch (process.platform) {
+			case "win32": return _existsSync(join(appData, "Zed"));
+			default: return _existsSync(join(configHome, "zed"));
+		}
+	}
+};
+//#endregion
+//#region node_modules/.pnpm/@getmcp+generators@0.10.1/node_modules/@getmcp/generators/dist/pycharm.js
+/**
+* PyCharm config generator.
+*
+* Config:   .ai/mcp/mcp.json (project-level) or IDE Settings → Tools → AI Assistant → MCP
+* Format:   { "mcpServers": { "name": { "command", "args", "env" } } }
+*
+* PyCharm's AI Assistant accepts MCP server configs in the same JSON format
+* as Claude Desktop — essentially a passthrough. Supports stdio, streamable-http,
+* and SSE transports.
+*
+* PyCharm supports project-level MCP configuration via .ai/mcp/mcp.json,
+* similar to how VS Code uses .vscode/mcp.json. This file is shareable via
+* version control and uses the canonical mcpServers format.
+*
+* Requires the JetBrains AI Assistant plugin:
+* https://plugins.jetbrains.com/plugin/22282-jetbrains-ai-assistant
+*
+* Important: PyCharm must be closed and reopened for config changes to take effect.
+*/
+var PyCharmGenerator = class extends BaseGenerator {
+	app = {
+		id: "pycharm",
+		name: "PyCharm",
+		description: "JetBrains PyCharm IDE with AI Assistant MCP integration",
+		configPaths: ".ai/mcp/mcp.json",
+		globalConfigPaths: null,
+		configFormat: "json",
+		docsUrl: "https://www.jetbrains.com/help/ai-assistant/mcp.html"
+	};
+};
+//#endregion
+//#region node_modules/.pnpm/smol-toml@1.6.1/node_modules/smol-toml/dist/stringify.js
+/*!
+* Copyright (c) Squirrel Chat et al., All rights reserved.
+* SPDX-License-Identifier: BSD-3-Clause
+*
+* Redistribution and use in source and binary forms, with or without
+* modification, are permitted provided that the following conditions are met:
+*
+* 1. Redistributions of source code must retain the above copyright notice, this
+*    list of conditions and the following disclaimer.
+* 2. Redistributions in binary form must reproduce the above copyright notice,
+*    this list of conditions and the following disclaimer in the
+*    documentation and/or other materials provided with the distribution.
+* 3. Neither the name of the copyright holder nor the names of its contributors
+*    may be used to endorse or promote products derived from this software without
+*    specific prior written permission.
+*
+* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+let BARE_KEY = /^[a-z0-9-_]+$/i;
+function extendedTypeOf(obj) {
+	let type = typeof obj;
+	if (type === "object") {
+		if (Array.isArray(obj)) return "array";
+		if (obj instanceof Date) return "date";
+	}
+	return type;
+}
+function isArrayOfTables(obj) {
+	for (let i = 0; i < obj.length; i++) if (extendedTypeOf(obj[i]) !== "object") return false;
+	return obj.length != 0;
+}
+function formatString(s) {
+	return JSON.stringify(s).replace(/\x7f/g, "\\u007f");
+}
+function stringifyValue(val, type, depth, numberAsFloat) {
+	if (depth === 0) throw new Error("Could not stringify the object: maximum object depth exceeded");
+	if (type === "number") {
+		if (isNaN(val)) return "nan";
+		if (val === Infinity) return "inf";
+		if (val === -Infinity) return "-inf";
+		if (numberAsFloat && Number.isInteger(val)) return val.toFixed(1);
+		return val.toString();
+	}
+	if (type === "bigint" || type === "boolean") return val.toString();
+	if (type === "string") return formatString(val);
+	if (type === "date") {
+		if (isNaN(val.getTime())) throw new TypeError("cannot serialize invalid date");
+		return val.toISOString();
+	}
+	if (type === "object") return stringifyInlineTable(val, depth, numberAsFloat);
+	if (type === "array") return stringifyArray(val, depth, numberAsFloat);
+}
+function stringifyInlineTable(obj, depth, numberAsFloat) {
+	let keys = Object.keys(obj);
+	if (keys.length === 0) return "{}";
+	let res = "{ ";
+	for (let i = 0; i < keys.length; i++) {
+		let k = keys[i];
+		if (i) res += ", ";
+		res += BARE_KEY.test(k) ? k : formatString(k);
+		res += " = ";
+		res += stringifyValue(obj[k], extendedTypeOf(obj[k]), depth - 1, numberAsFloat);
+	}
+	return res + " }";
+}
+function stringifyArray(array, depth, numberAsFloat) {
+	if (array.length === 0) return "[]";
+	let res = "[ ";
+	for (let i = 0; i < array.length; i++) {
+		if (i) res += ", ";
+		if (array[i] === null || array[i] === void 0) throw new TypeError("arrays cannot contain null or undefined values");
+		res += stringifyValue(array[i], extendedTypeOf(array[i]), depth - 1, numberAsFloat);
+	}
+	return res + " ]";
+}
+function stringifyArrayTable(array, key, depth, numberAsFloat) {
+	if (depth === 0) throw new Error("Could not stringify the object: maximum object depth exceeded");
+	let res = "";
+	for (let i = 0; i < array.length; i++) {
+		res += `${res && "\n"}[[${key}]]\n`;
+		res += stringifyTable(0, array[i], key, depth, numberAsFloat);
+	}
+	return res;
+}
+function stringifyTable(tableKey, obj, prefix, depth, numberAsFloat) {
+	if (depth === 0) throw new Error("Could not stringify the object: maximum object depth exceeded");
+	let preamble = "";
+	let tables = "";
+	let keys = Object.keys(obj);
+	for (let i = 0; i < keys.length; i++) {
+		let k = keys[i];
+		if (obj[k] !== null && obj[k] !== void 0) {
+			let type = extendedTypeOf(obj[k]);
+			if (type === "symbol" || type === "function") throw new TypeError(`cannot serialize values of type '${type}'`);
+			let key = BARE_KEY.test(k) ? k : formatString(k);
+			if (type === "array" && isArrayOfTables(obj[k])) tables += (tables && "\n") + stringifyArrayTable(obj[k], prefix ? `${prefix}.${key}` : key, depth - 1, numberAsFloat);
+			else if (type === "object") {
+				let tblKey = prefix ? `${prefix}.${key}` : key;
+				tables += (tables && "\n") + stringifyTable(tblKey, obj[k], tblKey, depth - 1, numberAsFloat);
+			} else {
+				preamble += key;
+				preamble += " = ";
+				preamble += stringifyValue(obj[k], type, depth, numberAsFloat);
+				preamble += "\n";
+			}
+		}
+	}
+	if (tableKey && (preamble || !tables)) preamble = preamble ? `[${tableKey}]\n${preamble}` : `[${tableKey}]`;
+	return preamble && tables ? `${preamble}\n${tables}` : preamble || tables;
+}
+function stringify(obj, { maxDepth = 1e3, numbersAsFloat = false } = {}) {
+	if (extendedTypeOf(obj) !== "object") throw new TypeError("stringify can only be called with an object");
+	let str = stringifyTable(0, obj, "", maxDepth, numbersAsFloat);
+	if (str[str.length - 1] !== "\n") return str + "\n";
+	return str;
+}
+//#endregion
+//#region node_modules/.pnpm/@getmcp+generators@0.10.1/node_modules/@getmcp/generators/dist/codex.js
+/**
+* Codex (OpenAI) config generator.
+*
+* Config file: ~/.codex/config.toml (TOML!)
+* Format:
+*   [mcp_servers.server-name]
+*   command = "npx"
+*   args = ["-y", "@package/name"]
+*
+*   [mcp_servers.server-name.env]
+*   API_KEY = "value"
+*
+* Remote (Streamable HTTP):
+*   [mcp_servers.remote-server]
+*   url = "https://mcp.example.com/mcp"
+*
+*   [mcp_servers.remote-server.http_headers]
+*   Authorization = "Bearer token"
+*
+* Key differences from canonical:
+*   - TOML format (not JSON)
+*   - Root key: "mcp_servers" (not "mcpServers")
+*   - "headers" → "http_headers"
+*   - "timeout" → "startup_timeout_sec" (ms to seconds)
+*   - No explicit "transport" field (Codex auto-detects)
+*/
+var CodexGenerator = class extends BaseGenerator {
+	app = {
+		id: "codex",
+		name: "Codex",
+		description: "OpenAI's AI coding agent",
+		configPaths: ".codex/config.toml",
+		globalConfigPaths: {
+			darwin: "~/.codex/config.toml",
+			win32: "%UserProfile%\\.codex\\config.toml",
+			linux: "~/.codex/config.toml"
+		},
+		configFormat: "toml",
+		docsUrl: "https://developers.openai.com/codex/mcp/"
+	};
+	generate(serverName, config) {
+		let serverConfig;
+		if (isStdioConfig(config)) serverConfig = {
+			command: config.command,
+			...config.args && config.args.length > 0 ? { args: config.args } : {},
+			...config.env && Object.keys(config.env).length > 0 ? { env: config.env } : {},
+			...config.cwd ? { cwd: config.cwd } : {},
+			...config.timeout ? { startup_timeout_sec: Math.ceil(config.timeout / 1e3) } : {},
+			...config.description ? { description: config.description } : {}
+		};
+		else if (isRemoteConfig(config)) serverConfig = {
+			url: config.url,
+			...config.headers && Object.keys(config.headers).length > 0 ? { http_headers: config.headers } : {},
+			...config.timeout ? { startup_timeout_sec: Math.ceil(config.timeout / 1e3) } : {},
+			...config.description ? { description: config.description } : {}
+		};
+		else throw new Error(INVALID_CONFIG_ERROR);
+		return { mcp_servers: { [serverName]: serverConfig } };
+	}
+	/**
+	* Serialize to TOML format using the `smol-toml` library.
+	*/
+	serialize(config) {
+		return stringify(config);
+	}
+	detectInstalled() {
+		return _existsSync(codexHome);
+	}
+};
+//#endregion
+//#region node_modules/.pnpm/@getmcp+generators@0.10.1/node_modules/@getmcp/generators/dist/gemini-cli.js
+/**
+* Gemini CLI config generator.
+*
+* Config file: ~/.gemini/settings.json
+* Format:      { "mcpServers": { "name": { "command", "args", "env" } } }
+*
+* Near-passthrough — Gemini CLI uses the same canonical mcpServers format.
+*/
+var GeminiCliGenerator = class extends BaseGenerator {
+	app = {
+		id: "gemini-cli",
+		name: "Gemini CLI",
+		description: "Google's Gemini CLI agent",
+		configPaths: null,
+		globalConfigPaths: {
+			darwin: "~/.gemini/settings.json",
+			win32: "%UserProfile%\\.gemini\\settings.json",
+			linux: "~/.gemini/settings.json"
+		},
+		configFormat: "json",
+		docsUrl: "https://github.com/google-gemini/gemini-cli"
+	};
+	detectInstalled() {
+		return _existsSync(join(home, ".gemini"));
+	}
+};
+//#endregion
+//#region node_modules/.pnpm/@getmcp+generators@0.10.1/node_modules/@getmcp/generators/dist/continue.js
+/**
+* Continue config generator.
+*
+* Config file: ~/.continue/config.json
+* Format:      { "mcpServers": { "name": { "command", "args", "env" } } }
+*
+* Near-passthrough — Continue uses the same canonical mcpServers format.
+*/
+var ContinueGenerator = class extends BaseGenerator {
+	app = {
+		id: "continue",
+		name: "Continue",
+		description: "Open-source AI code assistant for VS Code and JetBrains",
+		configPaths: null,
+		globalConfigPaths: {
+			darwin: "~/.continue/config.json",
+			win32: "%UserProfile%\\.continue\\config.json",
+			linux: "~/.continue/config.json"
+		},
+		configFormat: "json",
+		docsUrl: "https://docs.continue.dev/customize/model-providers/mcp"
+	};
+	detectInstalled() {
+		return _existsSync(join(home, ".continue"));
+	}
+};
+//#endregion
+//#region node_modules/.pnpm/@getmcp+generators@0.10.1/node_modules/@getmcp/generators/dist/amazon-q.js
+/**
+* Amazon Q Developer config generator.
+*
+* Config file: ~/.aws/amazonq/mcp.json
+* Format:      { "mcpServers": { "name": { "command", "args", "env" } } }
+*
+* Near-passthrough — Amazon Q uses the same canonical mcpServers format.
+*/
+var AmazonQGenerator = class extends BaseGenerator {
+	app = {
+		id: "amazon-q",
+		name: "Amazon Q Developer",
+		description: "AWS AI coding assistant",
+		configPaths: null,
+		globalConfigPaths: {
+			darwin: "~/.aws/amazonq/mcp.json",
+			win32: "%UserProfile%\\.aws\\amazonq\\mcp.json",
+			linux: "~/.aws/amazonq/mcp.json"
+		},
+		configFormat: "json",
+		docsUrl: "https://docs.aws.amazon.com/amazonq/latest/qdeveloper-ug/mcp.html"
+	};
+	detectInstalled() {
+		return _existsSync(join(home, ".aws", "amazonq"));
+	}
+};
+//#endregion
+//#region node_modules/.pnpm/@getmcp+generators@0.10.1/node_modules/@getmcp/generators/dist/trae.js
+/**
+* Trae config generator.
+*
+* Config file: .trae/mcp.json (project-scoped)
+* Format:      { "mcpServers": { "name": { "command", "args", "env" } } }
+*
+* Near-passthrough — Trae uses the same canonical mcpServers format.
+* Project-scoped configuration.
+*/
+var TraeGenerator = class extends BaseGenerator {
+	app = {
+		id: "trae",
+		name: "Trae",
+		description: "ByteDance's AI-powered IDE",
+		configPaths: ".trae/mcp.json",
+		globalConfigPaths: null,
+		configFormat: "json",
+		docsUrl: "https://docs.trae.ai/ide/model-context-protocol-mcp"
+	};
+	detectInstalled() {
+		return _existsSync(join(home, ".trae"));
+	}
+};
+//#endregion
+//#region node_modules/.pnpm/@getmcp+generators@0.10.1/node_modules/@getmcp/generators/dist/bolt-ai.js
+/**
+* Bolt AI config generator.
+*
+* Config file: ~/Library/Application Support/BoltAI/mcp_config.json (macOS only)
+* Format:      { "mcpServers": { "name": { "command", "args", "env" } } }
+*
+* Near-passthrough — Bolt AI uses the same canonical mcpServers format.
+* macOS-only application.
+*/
+var BoltAIGenerator = class extends BaseGenerator {
+	app = {
+		id: "bolt-ai",
+		name: "BoltAI",
+		description: "Native macOS AI chat client",
+		configPaths: null,
+		globalConfigPaths: { darwin: "~/Library/Application Support/BoltAI/mcp_config.json" },
+		configFormat: "json",
+		docsUrl: "https://docs.boltai.com/docs/mcp/overview"
+	};
+	detectInstalled() {
+		if (process.platform !== "darwin") return false;
+		return _existsSync(join(home, "Library", "Application Support", "BoltAI"));
+	}
+};
+//#endregion
+//#region node_modules/.pnpm/@getmcp+generators@0.10.1/node_modules/@getmcp/generators/dist/libre-chat.js
+/**
+* LibreChat config generator.
+*
+* Config file: librechat.yaml
+* Format (YAML):
+*   mcpServers:
+*     name:
+*       command: npx
+*       args: [-y, @package/name]
+*       env:
+*         KEY: value
+*
+* Key differences from canonical:
+*   - YAML format (not JSON)
+*   - Otherwise uses the same mcpServers root key and field names
+*/
+var LibreChatGenerator = class extends BaseGenerator {
+	app = {
+		id: "libre-chat",
+		name: "LibreChat",
+		description: "Open-source AI chat platform with multi-provider support",
+		configPaths: "librechat.yaml",
+		globalConfigPaths: null,
+		configFormat: "yaml",
+		docsUrl: "https://www.librechat.ai/docs/configuration/mcp_servers"
+	};
+	/**
+	* Serialize to YAML format.
+	*/
+	serialize(config) {
+		return import_dist.stringify(config, { indent: 2 });
+	}
+};
+//#endregion
+//#region node_modules/.pnpm/@getmcp+generators@0.10.1/node_modules/@getmcp/generators/dist/antigravity.js
+/**
+* Google Antigravity IDE config generator.
+*
+* Config file: ~/.gemini/antigravity/mcp_config.json
+* Format:      { "mcpServers": { "name": { "command", "args", "env" } } }
+*
+* Near-passthrough — Antigravity uses the same canonical mcpServers format.
+*/
+var AntigravityGenerator = class extends BaseGenerator {
+	app = {
+		id: "antigravity",
+		name: "Antigravity",
+		description: "Google's AI-first IDE",
+		configPaths: null,
+		globalConfigPaths: {
+			darwin: "~/.gemini/antigravity/mcp_config.json",
+			win32: "%UserProfile%\\.gemini\\antigravity\\mcp_config.json",
+			linux: "~/.gemini/antigravity/mcp_config.json"
+		},
+		configFormat: "json",
+		docsUrl: "https://antigravity.google/docs/mcp"
+	};
+	detectInstalled() {
+		return _existsSync(join(home, ".gemini", "antigravity"));
+	}
+};
+//#endregion
+//#region node_modules/.pnpm/@getmcp+generators@0.10.1/node_modules/@getmcp/generators/dist/index.js
+/**
+* @getmcp/generators
+*
+* Config generators that transform canonical MCP server definitions
+* into app-specific configuration formats for 19 AI applications.
+*/
+/**
+* Map of all available generators, keyed by AppId.
+*/
+const generators = {
+	"claude-desktop": new ClaudeDesktopGenerator(),
+	"claude-code": new ClaudeCodeGenerator(),
+	vscode: new VSCodeGenerator(),
+	cursor: new CursorGenerator(),
+	cline: new ClineGenerator(),
+	"roo-code": new RooCodeGenerator(),
+	goose: new GooseGenerator(),
+	windsurf: new WindsurfGenerator(),
+	opencode: new OpenCodeGenerator(),
+	zed: new ZedGenerator(),
+	pycharm: new PyCharmGenerator(),
+	codex: new CodexGenerator(),
+	"gemini-cli": new GeminiCliGenerator(),
+	continue: new ContinueGenerator(),
+	"amazon-q": new AmazonQGenerator(),
+	trae: new TraeGenerator(),
+	"bolt-ai": new BoltAIGenerator(),
+	"libre-chat": new LibreChatGenerator(),
+	antigravity: new AntigravityGenerator()
+};
+/**
+* Get a generator by app ID.
+*/
+function getGenerator(appId) {
+	const gen = generators[appId];
+	if (!gen) throw new Error(`No generator found for app: ${appId}`);
+	return gen;
+}
+/**
+* Get all available app IDs.
+*/
+function getAppIds() {
+	return Object.keys(generators);
+}
+/**
+* Generate config for a specific app from a canonical server definition.
+*/
+function generateConfig(appId, serverName, config) {
+	return getGenerator(appId).generate(serverName, config);
+}
+//#endregion
+export { deepMerge, generateConfig, generators, getAppIds };