@mastra/code-sdk 0.0.0-esbuild-bundle-worker-20260807173433

package/dist/mcp/manager.js

@@ -0,0 +1,612 @@
+import { DEFAULT_CONFIG_DIR } from "../constants.js";
+import { getAppDataDir } from "../utils/project.js";
+import { DEFAULT_OAUTH_REDIRECT_URL, getClaudeSettingsPath, getGlobalMcpPath, getProjectMcpPath, loadMcpConfig, resolveOAuthRedirectUrl } from "./config.js";
+import { loadDisabledServers, loadGlobalDisableState, saveDisabledServers, saveGlobalDisableState } from "./state.js";
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "fs";
+import { dirname, join } from "path";
+import { MCPClient, MCPOAuthClientProvider } from "@mastra/mcp";
+//#region src/mcp/manager.ts
+/**
+* MCP manager — orchestrates MCP server connections using MCPClient directly.
+* Created once at startup, provides tools from connected MCP servers.
+*/
+const MASTRACODE_MCP_TIMEOUT_MS = 10080 * 60 * 1e3;
+function getTransport(cfg) {
+	return "url" in cfg ? "http" : "stdio";
+}
+var FileOAuthStorage = class {
+	filePath;
+	constructor(filePath) {
+		this.filePath = filePath;
+	}
+	get(key) {
+		return this.read()[key];
+	}
+	set(key, value) {
+		const data = this.read();
+		data[key] = value;
+		this.write(data);
+	}
+	delete(key) {
+		const data = this.read();
+		delete data[key];
+		this.write(data);
+	}
+	read() {
+		if (!existsSync(this.filePath)) return {};
+		try {
+			return JSON.parse(readFileSync(this.filePath, "utf-8"));
+		} catch {
+			return {};
+		}
+	}
+	write(data) {
+		const dir = dirname(this.filePath);
+		if (!existsSync(dir)) mkdirSync(dir, {
+			recursive: true,
+			mode: 448
+		});
+		const tmpPath = `${this.filePath}.tmp`;
+		writeFileSync(tmpPath, JSON.stringify(data, null, 2), {
+			encoding: "utf-8",
+			mode: 384
+		});
+		renameSync(tmpPath, this.filePath);
+	}
+};
+/**
+* Zero-config OAuth defaults for servers with a bare `url` entry. Dynamic
+* client registration provisions the client, so no `clientId` is needed.
+*/
+const DEFAULT_OAUTH_CONFIG = { redirectUrl: DEFAULT_OAUTH_REDIRECT_URL };
+function getOAuthStoragePath(projectDir, name, cfg) {
+	const key = JSON.stringify({
+		projectDir,
+		name,
+		url: cfg.url,
+		redirectUrl: resolveOAuthRedirectUrl(cfg.oauth),
+		clientId: cfg.oauth?.clientId,
+		scopes: cfg.oauth?.scopes ?? []
+	});
+	return join(getAppDataDir(), "mcp-oauth", `${getStorageKeyFingerprint(key)}.json`);
+}
+function getStorageKeyFingerprint(value) {
+	let fingerprint = 14695981039346656037n;
+	for (let i = 0; i < value.length; i += 1) {
+		fingerprint ^= BigInt(value.charCodeAt(i));
+		fingerprint = BigInt.asUintN(64, fingerprint * 1099511628211n);
+	}
+	return fingerprint.toString(16).padStart(16, "0");
+}
+/**
+* Create an MCP manager that wraps MCPClient with config-file discovery
+* and per-server status tracking.
+*/
+function createMcpManager(projectDir, configDirName = DEFAULT_CONFIG_DIR, extraServers) {
+	/** Merge programmatic servers into a base config (highest priority). */
+	const applyExtraServers = (base) => {
+		if (!extraServers || Object.keys(extraServers).length === 0) return base;
+		return {
+			...base,
+			mcpServers: {
+				...base.mcpServers,
+				...extraServers
+			}
+		};
+	};
+	let config = applyExtraServers(loadMcpConfig(projectDir, configDirName));
+	let disabledServers = new Set(loadDisabledServers(projectDir));
+	let globalDisableState = loadGlobalDisableState();
+	let globallyDisabledServers = new Set(globalDisableState.disabledServers);
+	/** Whether a server is disabled in any scope (global kill switch, global list, or project list). */
+	const isDisabled = (name) => globalDisableState.allDisabled || globallyDisabledServers.has(name) || disabledServers.has(name);
+	/** Which scope disables a server. Global takes precedence — project-level enable can't undo it. */
+	const disabledScopeOf = (name) => {
+		if (globalDisableState.allDisabled || globallyDisabledServers.has(name)) return "global";
+		if (disabledServers.has(name)) return "project";
+	};
+	let client = null;
+	let serverDefs = {};
+	let tools = {};
+	let serverStatuses = /* @__PURE__ */ new Map();
+	let stderrLogs = /* @__PURE__ */ new Map();
+	let initialized = false;
+	/** Per-server handlers that receive the OAuth authorization URL during authenticateServer(). */
+	const authUrlHandlers = /* @__PURE__ */ new Map();
+	/**
+	* Servers with an OAuth authorization flow currently in flight. Owned by the
+	* manager (not the TUI) so the state survives a `/mcp` selector being closed
+	* and reopened — the reopened selector reads it back off the server status and
+	* can still offer "Cancel authentication".
+	*/
+	const authenticatingServers = /* @__PURE__ */ new Set();
+	/**
+	* Servers whose in-flight authentication was cancelled by the caller. Set by
+	* cancelServerAuthentication() so the resolving authenticateServer() call can
+	* mark its failed status as a deliberate cancel rather than a genuine failure.
+	* This lives on the manager (not the TUI selector) so the signal survives the
+	* selector being closed and reopened mid-flow.
+	*/
+	const cancelledAuthServers = /* @__PURE__ */ new Set();
+	/** Overlay the manager-owned `authenticating` flag onto a status snapshot. */
+	const withAuthenticating = (status) => authenticatingServers.has(status.name) ? {
+		...status,
+		authenticating: true
+	} : status;
+	const MAX_STDERR_LINES = 200;
+	/** Hook into a server's stderr stream and buffer its output. */
+	function captureStderr(serverName) {
+		if (!client || typeof client.getServerStderr !== "function") return;
+		const stream = client.getServerStderr(serverName);
+		if (!stream) return;
+		let buffer = "";
+		const lines = stderrLogs.get(serverName) ?? [];
+		stderrLogs.set(serverName, lines);
+		stream.on("data", (chunk) => {
+			buffer += chunk.toString();
+			const parts = buffer.split("\n");
+			buffer = parts.pop();
+			for (const line of parts) if (line.trim()) {
+				lines.push(line);
+				if (lines.length > MAX_STDERR_LINES) lines.shift();
+			}
+		});
+		stream.on("end", () => {
+			if (buffer.trim()) {
+				lines.push(buffer);
+				if (lines.length > MAX_STDERR_LINES) lines.shift();
+			}
+		});
+	}
+	function createOAuthProvider(name, cfg) {
+		const oauth = cfg.oauth ?? (existsSync(getOAuthStoragePath(projectDir, name, cfg)) ? DEFAULT_OAUTH_CONFIG : void 0);
+		if (!oauth) return void 0;
+		const redirectUrl = resolveOAuthRedirectUrl(oauth);
+		return new MCPOAuthClientProvider({
+			redirectUrl,
+			clientMetadata: {
+				redirect_uris: [redirectUrl],
+				client_name: oauth.clientName ?? `Mastra Code MCP ${name}`,
+				grant_types: ["authorization_code", "refresh_token"],
+				response_types: ["code"],
+				...oauth.scopes?.length ? { scope: oauth.scopes.join(" ") } : {}
+			},
+			clientInformation: oauth.clientId ? {
+				client_id: oauth.clientId,
+				...oauth.clientSecret ? { client_secret: oauth.clientSecret } : {}
+			} : void 0,
+			storage: new FileOAuthStorage(getOAuthStoragePath(projectDir, name, cfg)),
+			onRedirectToAuthorization: (url) => {
+				authUrlHandlers.get(name)?.(url.toString());
+			}
+		});
+	}
+	function buildServerDefs(servers) {
+		const defs = {};
+		for (const [name, cfg] of Object.entries(servers)) if ("url" in cfg) {
+			const httpCfg = cfg;
+			defs[name] = {
+				url: new URL(httpCfg.url),
+				requestInit: httpCfg.headers ? { headers: httpCfg.headers } : void 0,
+				authProvider: createOAuthProvider(name, httpCfg)
+			};
+		} else defs[name] = {
+			command: cfg.command,
+			args: cfg.args,
+			env: cfg.env,
+			stderr: "pipe"
+		};
+		return defs;
+	}
+	/** Seed a `disabled` status for every disabled server so it stays visible. */
+	function setDisabledStatuses() {
+		for (const [name, cfg] of Object.entries(config.mcpServers ?? {})) {
+			const scope = disabledScopeOf(name);
+			if (!scope) continue;
+			serverStatuses.set(name, {
+				name,
+				connected: false,
+				toolCount: 0,
+				toolNames: [],
+				transport: getTransport(cfg),
+				disabled: true,
+				disabledScope: scope
+			});
+		}
+	}
+	async function connectAndCollectTools() {
+		setDisabledStatuses();
+		const servers = Object.fromEntries(Object.entries(config.mcpServers ?? {}).filter(([name]) => !isDisabled(name)));
+		if (Object.keys(servers).length === 0) return;
+		const serverNames = Object.keys(servers);
+		for (const name of serverNames) serverStatuses.set(name, {
+			name,
+			connected: false,
+			connecting: true,
+			toolCount: 0,
+			toolNames: [],
+			transport: getTransport(servers[name])
+		});
+		serverDefs = buildServerDefs(servers);
+		client = new MCPClient({
+			id: "mastra-code-mcp",
+			servers: serverDefs,
+			timeout: MASTRACODE_MCP_TIMEOUT_MS
+		});
+		try {
+			const { toolsets, errors } = await client.listToolsetsWithErrors();
+			const typedToolsets = toolsets;
+			for (const [serverName, serverTools] of Object.entries(typedToolsets)) for (const [toolName, toolConfig] of Object.entries(serverTools)) tools[`${serverName}_${toolName}`] = toolConfig;
+			for (const name of serverNames) {
+				const serverTools = typedToolsets[name];
+				if (serverTools && Object.keys(serverTools).length > 0) {
+					const toolNames = Object.keys(serverTools).map((t) => `${name}_${t}`);
+					serverStatuses.set(name, {
+						name,
+						connected: true,
+						toolCount: toolNames.length,
+						toolNames,
+						transport: getTransport(servers[name])
+					});
+				} else {
+					const error = errors[name] ?? "Failed to connect";
+					serverStatuses.set(name, {
+						name,
+						connected: false,
+						toolCount: 0,
+						toolNames: [],
+						transport: getTransport(servers[name]),
+						error,
+						...serverNeedsAuth(name, servers[name], error) ? { needsAuth: true } : {}
+					});
+				}
+			}
+			for (const name of serverNames) captureStderr(name);
+		} catch (error) {
+			const errMsg = error instanceof Error ? error.message : String(error);
+			for (const name of serverNames) serverStatuses.set(name, {
+				name,
+				connected: false,
+				toolCount: 0,
+				toolNames: [],
+				transport: getTransport(servers[name]),
+				error: errMsg,
+				...serverNeedsAuth(name, servers[name], errMsg) ? { needsAuth: true } : {}
+			});
+		}
+	}
+	/**
+	* Whether a failed HTTP server is blocked on OAuth authorization.
+	*
+	* Provider-backed servers report the exact state tracked by `@mastra/mcp`.
+	* Bare `url` entries carry no provider until the user authenticates, so the
+	* signal is a 401 in the connect error — surfaced either as the status text
+	* or as the RFC 6750 `invalid_token` bearer error code in the response body.
+	*/
+	function serverNeedsAuth(name, cfg, error) {
+		if (getTransport(cfg) !== "http") return false;
+		if (client?.getServerAuthState?.(name) === "needs-auth") return true;
+		if (serverDefs[name]?.authProvider) return false;
+		return error !== void 0 && /\b401\b|unauthorized|invalid_token/i.test(error);
+	}
+	/**
+	* Runs a single-server connect action (reconnect or authenticate), then
+	* refreshes that server's tools and status from the client.
+	*/
+	async function connectSingleServer(name, cfg, connect) {
+		const transport = getTransport(cfg);
+		const prefix = `${name}_`;
+		for (const key of Object.keys(tools)) if (key.startsWith(prefix)) delete tools[key];
+		stderrLogs.delete(name);
+		serverStatuses.set(name, {
+			name,
+			connected: false,
+			connecting: true,
+			toolCount: 0,
+			toolNames: [],
+			transport
+		});
+		try {
+			await connect();
+			captureStderr(name);
+			const { toolsets, errors } = await client.listToolsetsWithErrors();
+			const serverTools = toolsets[name];
+			const serverError = errors[name];
+			if (serverError) {
+				const status = {
+					name,
+					connected: false,
+					toolCount: 0,
+					toolNames: [],
+					transport,
+					error: serverError,
+					...serverNeedsAuth(name, cfg, serverError) ? { needsAuth: true } : {}
+				};
+				serverStatuses.set(name, status);
+				return status;
+			} else if (serverTools && Object.keys(serverTools).length > 0) {
+				const toolNames = Object.keys(serverTools).map((t) => `${name}_${t}`);
+				for (const [toolName, toolConfig] of Object.entries(serverTools)) tools[`${name}_${toolName}`] = toolConfig;
+				const status = {
+					name,
+					connected: true,
+					toolCount: toolNames.length,
+					toolNames,
+					transport
+				};
+				serverStatuses.set(name, status);
+				return status;
+			} else {
+				const status = {
+					name,
+					connected: false,
+					toolCount: 0,
+					toolNames: [],
+					transport,
+					error: "Failed to connect"
+				};
+				serverStatuses.set(name, status);
+				return status;
+			}
+		} catch (error) {
+			const errMsg = error instanceof Error ? error.message : String(error);
+			const status = {
+				name,
+				connected: false,
+				toolCount: 0,
+				toolNames: [],
+				transport,
+				error: errMsg,
+				...serverNeedsAuth(name, cfg, errMsg) ? { needsAuth: true } : {}
+			};
+			serverStatuses.set(name, status);
+			return status;
+		}
+	}
+	async function disconnect() {
+		if (client) {
+			try {
+				await client.disconnect();
+			} catch {}
+			client = null;
+		}
+	}
+	/** Tear down all connections and reconnect every enabled server. */
+	async function rebuildConnections() {
+		await disconnect();
+		tools = {};
+		serverStatuses = /* @__PURE__ */ new Map();
+		stderrLogs = /* @__PURE__ */ new Map();
+		initialized = false;
+		await connectAndCollectTools();
+		initialized = true;
+	}
+	function disabledStatus(name) {
+		const cfg = config.mcpServers?.[name];
+		return {
+			name,
+			connected: false,
+			toolCount: 0,
+			toolNames: [],
+			transport: cfg ? getTransport(cfg) : "stdio",
+			disabled: true,
+			disabledScope: disabledScopeOf(name)
+		};
+	}
+	function persistProjectDelta(mutate) {
+		const fresh = new Set(loadDisabledServers(projectDir));
+		mutate(fresh);
+		disabledServers = fresh;
+		saveDisabledServers(projectDir, Array.from(fresh));
+	}
+	function persistGlobalDelta(mutate) {
+		const onDisk = loadGlobalDisableState();
+		const fresh = {
+			allDisabled: onDisk.allDisabled,
+			disabledServers: new Set(onDisk.disabledServers)
+		};
+		mutate(fresh);
+		globallyDisabledServers = fresh.disabledServers;
+		globalDisableState = {
+			allDisabled: fresh.allDisabled,
+			disabledServers: Array.from(fresh.disabledServers)
+		};
+		saveGlobalDisableState(globalDisableState);
+	}
+	return {
+		async init() {
+			if (initialized) return;
+			await connectAndCollectTools();
+			initialized = true;
+		},
+		async initInBackground() {
+			await this.init();
+			const statuses = Array.from(serverStatuses.values());
+			const connected = statuses.filter((s) => s.connected);
+			return {
+				connected,
+				failed: statuses.filter((s) => !s.connected && !s.disabled),
+				skipped: [...config.skippedServers ?? []],
+				totalTools: connected.reduce((sum, s) => sum + s.toolCount, 0)
+			};
+		},
+		async reload() {
+			config = applyExtraServers(loadMcpConfig(projectDir, configDirName));
+			disabledServers = new Set(loadDisabledServers(projectDir));
+			globalDisableState = loadGlobalDisableState();
+			globallyDisabledServers = new Set(globalDisableState.disabledServers);
+			await rebuildConnections();
+		},
+		async setServerDisabled(name, disabled, options) {
+			if (!config.mcpServers?.[name]) return {
+				name,
+				connected: false,
+				toolCount: 0,
+				toolNames: [],
+				transport: "stdio",
+				error: `Server "${name}" not found in config`
+			};
+			const wasEffectivelyDisabled = isDisabled(name);
+			if (options?.global) persistGlobalDelta((state) => {
+				if (disabled) state.disabledServers.add(name);
+				else state.disabledServers.delete(name);
+			});
+			else persistProjectDelta((names) => {
+				if (disabled) names.add(name);
+				else names.delete(name);
+			});
+			if (isDisabled(name) !== wasEffectivelyDisabled) {
+				await rebuildConnections();
+				return withAuthenticating(serverStatuses.get(name) ?? disabledStatus(name));
+			}
+			return withAuthenticating(isDisabled(name) ? disabledStatus(name) : serverStatuses.get(name) ?? disabledStatus(name));
+		},
+		async setAllDisabled(disabled, options) {
+			const configuredNames = Object.keys(config.mcpServers ?? {});
+			const effectiveBefore = configuredNames.filter((name) => isDisabled(name)).join(",");
+			if (options?.global) persistGlobalDelta((state) => {
+				state.allDisabled = disabled;
+				if (!disabled) state.disabledServers.clear();
+			});
+			else persistProjectDelta((names) => {
+				if (disabled) for (const name of configuredNames) names.add(name);
+				else names.clear();
+			});
+			if (configuredNames.filter((name) => isDisabled(name)).join(",") !== effectiveBefore) await rebuildConnections();
+		},
+		getDisabledServers() {
+			return Object.keys(config.mcpServers ?? {}).filter((name) => isDisabled(name)).sort();
+		},
+		isAllDisabledGlobally() {
+			return globalDisableState.allDisabled;
+		},
+		async reconnectServer(name) {
+			if (isDisabled(name)) return {
+				...disabledStatus(name),
+				error: `Server "${name}" is disabled — enable it first`
+			};
+			const cfg = config.mcpServers?.[name];
+			if (!cfg) return {
+				name,
+				connected: false,
+				toolCount: 0,
+				toolNames: [],
+				transport: "stdio",
+				error: `Server "${name}" not found in config`
+			};
+			if (!client) return {
+				name,
+				connected: false,
+				toolCount: 0,
+				toolNames: [],
+				transport: getTransport(cfg),
+				error: "MCP client not initialized"
+			};
+			return connectSingleServer(name, cfg, () => client.reconnectServer(name));
+		},
+		async authenticateServer(name, options) {
+			const cfg = config.mcpServers?.[name];
+			if (!cfg) return {
+				name,
+				connected: false,
+				toolCount: 0,
+				toolNames: [],
+				transport: "stdio",
+				error: `Server "${name}" not found in config`
+			};
+			if (isDisabled(name)) return {
+				...disabledStatus(name),
+				error: `Server "${name}" is disabled — enable it first`
+			};
+			if (!client) return {
+				name,
+				connected: false,
+				toolCount: 0,
+				toolNames: [],
+				transport: getTransport(cfg),
+				error: "MCP client not initialized"
+			};
+			if (getTransport(cfg) !== "http") return {
+				name,
+				connected: false,
+				toolCount: 0,
+				toolNames: [],
+				transport: "stdio",
+				error: `Server "${name}" uses stdio transport, which does not support OAuth`
+			};
+			const def = serverDefs[name];
+			if (def?.url && !def.authProvider) def.authProvider = createOAuthProvider(name, {
+				...cfg,
+				oauth: DEFAULT_OAUTH_CONFIG
+			});
+			if (authenticatingServers.has(name)) {
+				const current = serverStatuses.get(name);
+				return {
+					name,
+					connected: current?.connected ?? false,
+					connecting: current?.connecting,
+					needsAuth: current?.needsAuth,
+					toolCount: current?.toolCount ?? 0,
+					toolNames: current?.toolNames ?? [],
+					transport: current?.transport ?? getTransport(cfg),
+					error: `Authentication for "${name}" is already in progress`
+				};
+			}
+			if (options?.onAuthorizationUrl) authUrlHandlers.set(name, options.onAuthorizationUrl);
+			authenticatingServers.add(name);
+			cancelledAuthServers.delete(name);
+			try {
+				const result = await connectSingleServer(name, cfg, () => client.authenticate(name, options?.timeoutMs === void 0 ? void 0 : { timeoutMs: options.timeoutMs }));
+				const finalStatus = cancelledAuthServers.has(name) && !result.connected ? {
+					...result,
+					cancelled: true
+				} : result;
+				serverStatuses.set(name, finalStatus);
+				return finalStatus;
+			} finally {
+				authUrlHandlers.delete(name);
+				authenticatingServers.delete(name);
+				cancelledAuthServers.delete(name);
+			}
+		},
+		async cancelServerAuthentication(name) {
+			if (!client) return false;
+			cancelledAuthServers.add(name);
+			const cancelled = await client.cancelAuthentication(name);
+			if (!cancelled) cancelledAuthServers.delete(name);
+			return cancelled;
+		},
+		disconnect,
+		getTools() {
+			return { ...tools };
+		},
+		hasServers() {
+			const hasConfigured = config.mcpServers !== void 0 && Object.keys(config.mcpServers).length > 0;
+			const hasSkipped = config.skippedServers !== void 0 && config.skippedServers.length > 0;
+			return hasConfigured || hasSkipped;
+		},
+		getServerStatuses() {
+			return Array.from(serverStatuses.values(), withAuthenticating);
+		},
+		getSkippedServers() {
+			return [...config.skippedServers ?? []];
+		},
+		getConfigPaths() {
+			return {
+				project: getProjectMcpPath(projectDir, configDirName),
+				global: getGlobalMcpPath(configDirName),
+				claude: getClaudeSettingsPath(projectDir)
+			};
+		},
+		getConfig() {
+			return config;
+		},
+		getServerLogs(name) {
+			return [...stderrLogs.get(name) ?? []];
+		}
+	};
+}
+//#endregion
+export { createMcpManager };
+
+//# sourceMappingURL=manager.js.map