@rudderhq/server 0.5.2-canary.2 → 0.6.0

package/dist/services/mcp/managed-client.js

@@ -0,0 +1,238 @@
+import { Client, SdkError, SdkErrorCode, SdkHttpError, StreamableHTTPClientTransport, UnauthorizedError, } from "@modelcontextprotocol/client";
+import { DEFAULT_INHERITED_ENV_VARS, StdioClientTransport, } from "@modelcontextprotocol/client/stdio";
+import { createSecureMcpFetch } from "./pinned-fetch.js";
+import { assertSafeMcpCredentialHeaders, assertSafeMcpHeaders, validateMcpStdioPolicy, } from "./security-policy.js";
+export class ManagedMcpClientError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.name = "ManagedMcpClientError";
+        this.code = code;
+    }
+}
+export function resolveMcpHttpCredentials(input) {
+    assertSafeMcpCredentialHeaders(input.secretHeaders ?? {});
+    const encryptedAuthorization = Object.entries(input.secretHeaders ?? {})
+        .find(([name]) => name.toLowerCase() === "authorization");
+    const authorizationSources = [
+        Boolean(input.bearerToken),
+        Boolean(input.authorizationHeader),
+        Boolean(encryptedAuthorization),
+        Boolean(input.oauth),
+    ].filter(Boolean).length;
+    if (authorizationSources > 1) {
+        throw new ManagedMcpClientError("mcp_conflicting_authorization", "Configure exactly one managed MCP Authorization source");
+    }
+    const headers = { ...(input.secretHeaders ?? {}) };
+    if (input.bearerToken)
+        headers.Authorization = `Bearer ${input.bearerToken}`;
+    if (input.authorizationHeader)
+        headers.Authorization = input.authorizationHeader;
+    return {
+        headers,
+        authProvider: input.oauth
+            ? {
+                token: () => input.oauth.token(),
+                onUnauthorized: async () => input.oauth.refresh(),
+            }
+            : undefined,
+        onUnauthorizedFailure: input.oauth?.markNeedsReauth
+            ? () => input.oauth.markNeedsReauth()
+            : undefined,
+    };
+}
+function isStdioOutputBoundaryError(error) {
+    return error instanceof Error && /ReadBuffer exceeded maximum size/u.test(error.message);
+}
+function safeClientError(error, action) {
+    if (error instanceof ManagedMcpClientError)
+        return error;
+    if (error instanceof UnauthorizedError || (error instanceof SdkHttpError && error.status === 401)) {
+        return new ManagedMcpClientError("mcp_upstream_unauthorized", "Managed MCP authorization was rejected");
+    }
+    if (error instanceof SdkHttpError && error.status === 429) {
+        return new ManagedMcpClientError("mcp_upstream_rate_limited", "Managed MCP upstream rate limit was reached");
+    }
+    if (error instanceof SdkError && error.code === SdkErrorCode.RequestTimeout) {
+        return new ManagedMcpClientError(action === "call" ? "mcp_tool_timeout" : "mcp_startup_timeout", action === "call"
+            ? "Managed MCP tool call timed out"
+            : "Managed MCP connection timed out");
+    }
+    return new ManagedMcpClientError(action === "call" ? "mcp_tool_failed" : "mcp_transport_failed", action === "call"
+        ? "Managed MCP tool call failed"
+        : "Managed MCP transport failed");
+}
+function boundedResult(result, maxOutputBytes) {
+    let bytes;
+    try {
+        bytes = Buffer.byteLength(JSON.stringify(result), "utf8");
+    }
+    catch {
+        throw new ManagedMcpClientError("mcp_result_invalid", "Managed MCP tool result is not JSON serializable");
+    }
+    if (bytes > maxOutputBytes) {
+        throw new ManagedMcpClientError("mcp_result_too_large", "Managed MCP tool result exceeds the output limit");
+    }
+    return result;
+}
+async function prepareStdioLaunch(options) {
+    const environmentNames = new Set([
+        ...Object.keys(options.staticEnv),
+        ...Object.keys(options.secretEnv),
+        ...options.forwardedEnv,
+    ]);
+    const target = await validateMcpStdioPolicy({
+        command: options.command,
+        args: options.args,
+        cwd: options.cwd,
+        environmentNames: [...environmentNames],
+    }, options.deploymentPolicy);
+    const env = {
+        ...options.staticEnv,
+        ...options.secretEnv,
+    };
+    for (const name of options.forwardedEnv) {
+        const value = options.hostEnv[name];
+        if (value !== undefined)
+            env[name] = value;
+    }
+    if (options.deploymentPolicy.deploymentMode === "authenticated") {
+        for (const name of DEFAULT_INHERITED_ENV_VARS) {
+            if (!environmentNames.has(name))
+                env[name] = "";
+        }
+    }
+    return { ...target, env };
+}
+export async function createManagedMcpClient(options) {
+    const sdkClient = new Client({ name: "rudder-managed-mcp", version: "1.0.0" }, { versionNegotiation: { mode: "legacy" } });
+    const maxOutputBytes = options.maxOutputBytes ?? 10 * 1024 * 1024;
+    let stderrBytes = 0;
+    let transport;
+    let stdioTransport = null;
+    let stdioOutputBoundaryExceeded = false;
+    let stdioClosedPromise = null;
+    let closePromise = null;
+    const closeSdkClient = () => {
+        if (closePromise)
+            return closePromise;
+        closePromise = (async () => {
+            try {
+                await sdkClient.close();
+                await stdioClosedPromise;
+            }
+            catch (error) {
+                closePromise = null;
+                throw error;
+            }
+        })();
+        return closePromise;
+    };
+    const mapClientError = async (error, action) => {
+        if (options.transport === "streamable_http"
+            && (error instanceof UnauthorizedError
+                || (error instanceof SdkHttpError && error.status === 401))) {
+            await options.credentials.onUnauthorizedFailure?.().catch(() => undefined);
+        }
+        return safeClientError(error, action);
+    };
+    if (options.transport === "streamable_http") {
+        assertSafeMcpHeaders(options.staticHeaders ?? {});
+        assertSafeMcpCredentialHeaders(options.credentials.headers);
+        const credentialAuthorization = Object.keys(options.credentials.headers)
+            .some((name) => name.toLowerCase() === "authorization");
+        if (credentialAuthorization && options.credentials.authProvider) {
+            throw new ManagedMcpClientError("mcp_conflicting_authorization", "Configure exactly one managed MCP Authorization source");
+        }
+        transport = new StreamableHTTPClientTransport(new URL(options.url), {
+            authProvider: options.credentials.authProvider,
+            requestInit: {
+                headers: {
+                    ...(options.staticHeaders ?? {}),
+                    ...options.credentials.headers,
+                },
+            },
+            fetch: createSecureMcpFetch({
+                ...options.network,
+                maxResponseBytes: maxOutputBytes,
+            }),
+            onInsufficientScope: "throw",
+        });
+    }
+    else {
+        const launch = await prepareStdioLaunch(options);
+        stdioTransport = new StdioClientTransport({
+            command: launch.command,
+            args: options.args,
+            cwd: launch.cwd,
+            env: launch.env,
+            stderr: "pipe",
+            maxBufferSize: maxOutputBytes,
+        });
+        transport = stdioTransport;
+        stdioTransport.stderr?.on("data", (chunk) => {
+            stderrBytes += Buffer.byteLength(chunk);
+            if (stderrBytes > maxOutputBytes) {
+                stdioOutputBoundaryExceeded = true;
+                void closeSdkClient().catch(() => undefined);
+            }
+        });
+    }
+    try {
+        await sdkClient.connect(transport, { timeout: options.startupTimeoutMs });
+    }
+    catch (error) {
+        await closeSdkClient().catch(() => undefined);
+        throw await mapClientError(error, "connect");
+    }
+    if (stdioTransport) {
+        let resolveStdioClosed = null;
+        stdioClosedPromise = new Promise((resolve) => {
+            resolveStdioClosed = resolve;
+        });
+        const clientCloseHandler = stdioTransport.onclose;
+        stdioTransport.onclose = () => {
+            try {
+                clientCloseHandler?.();
+            }
+            finally {
+                resolveStdioClosed?.();
+            }
+        };
+        const clientErrorHandler = stdioTransport.onerror;
+        stdioTransport.onerror = (error) => {
+            if (isStdioOutputBoundaryError(error)) {
+                stdioOutputBoundaryExceeded = true;
+                void closeSdkClient().catch(() => undefined);
+            }
+            clientErrorHandler?.(error);
+        };
+    }
+    return {
+        async discoverTools() {
+            try {
+                const result = await sdkClient.listTools(undefined, { timeout: options.startupTimeoutMs, cacheMode: "refresh" });
+                return result.tools;
+            }
+            catch (error) {
+                throw await mapClientError(error, "discover");
+            }
+        },
+        async callTool(name, args) {
+            try {
+                const result = await sdkClient.callTool({ name, arguments: args }, { timeout: options.toolTimeoutMs });
+                return boundedResult(result, maxOutputBytes);
+            }
+            catch (error) {
+                if (stdioOutputBoundaryExceeded) {
+                    throw new ManagedMcpClientError("mcp_result_too_large", "Managed MCP tool result exceeds the output limit");
+                }
+                throw await mapClientError(error, "call");
+            }
+        },
+        async close() {
+            await closeSdkClient();
+        },
+    };
+}
+//# sourceMappingURL=managed-client.js.map

package/dist/services/mcp/managed-client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"managed-client.js","sourceRoot":"","sources":["../../../src/services/mcp/managed-client.ts"],"names":[],"mappings":"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"}

package/dist/services/mcp/managed-client.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=managed-client.test.d.ts.map

package/dist/services/mcp/managed-client.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"managed-client.test.d.ts","sourceRoot":"","sources":["../../../src/services/mcp/managed-client.test.ts"],"names":[],"mappings":""}

package/dist/services/mcp/managed-client.test.js

@@ -0,0 +1,398 @@
+import { mkdir, mkdtemp, realpath, stat, symlink } from "node:fs/promises";
+import { createServer } from "node:http";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { afterEach, describe, expect, it } from "vitest";
+import { createManagedMcpClient, resolveMcpHttpCredentials, } from "./managed-client.js";
+async function readJson(req) {
+    const chunks = [];
+    for await (const chunk of req)
+        chunks.push(Buffer.from(chunk));
+    return JSON.parse(Buffer.concat(chunks).toString("utf8"));
+}
+function json(res, status, body) {
+    res.writeHead(status, { "content-type": "application/json" });
+    res.end(JSON.stringify(body));
+}
+async function startMockMcpServer(options = {}) {
+    const requests = [];
+    const server = createServer(async (req, res) => {
+        if (req.method === "GET") {
+            res.writeHead(405);
+            res.end();
+            return;
+        }
+        if (req.method === "DELETE") {
+            res.writeHead(200);
+            res.end();
+            return;
+        }
+        if (options.redirectOnce && req.url === "/redirect") {
+            res.writeHead(307, { location: "/mcp" });
+            res.end();
+            return;
+        }
+        const message = await readJson(req);
+        const authorization = req.headers.authorization;
+        requests.push({ method: message.method, authorization });
+        const acceptedBearer = options.refreshBearer ?? options.requiredBearer;
+        if (options.alwaysUnauthorized
+            || (acceptedBearer && authorization !== `Bearer ${acceptedBearer}`)) {
+            res.writeHead(401, { "www-authenticate": "Bearer" });
+            res.end();
+            return;
+        }
+        if (options.rateLimitTools && message.method === "tools/list") {
+            res.writeHead(429, { "retry-after": "1" });
+            res.end();
+            return;
+        }
+        if (message.method === "notifications/initialized") {
+            res.writeHead(202);
+            res.end();
+            return;
+        }
+        if (message.method === "initialize") {
+            json(res, 200, {
+                jsonrpc: "2.0",
+                id: message.id,
+                result: {
+                    protocolVersion: "2025-06-18",
+                    capabilities: { tools: {} },
+                    serverInfo: { name: "rudder-http-fixture", version: "1.0.0" },
+                },
+            });
+            return;
+        }
+        if (message.method === "tools/list") {
+            json(res, 200, {
+                jsonrpc: "2.0",
+                id: message.id,
+                result: {
+                    tools: [{
+                            name: "echo",
+                            description: "Echo an input",
+                            inputSchema: {
+                                type: "object",
+                                properties: { value: { type: "string" } },
+                            },
+                        }],
+                },
+            });
+            return;
+        }
+        if (message.method === "tools/call") {
+            json(res, 200, {
+                jsonrpc: "2.0",
+                id: message.id,
+                result: {
+                    content: [{ type: "text", text: message.params.arguments.value }],
+                    structuredContent: { echoed: message.params.arguments.value },
+                },
+            });
+            return;
+        }
+        json(res, 404, {});
+    });
+    await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
+    const address = server.address();
+    if (!address || typeof address === "string")
+        throw new Error("Missing fixture address");
+    return {
+        origin: `http://127.0.0.1:${address.port}`,
+        requests,
+        close: () => new Promise((resolve, reject) => {
+            server.close((error) => error ? reject(error) : resolve());
+        }),
+    };
+}
+const clients = [];
+const servers = [];
+afterEach(async () => {
+    await Promise.allSettled(clients.splice(0).map((client) => client.close()));
+    await Promise.allSettled(servers.splice(0).map((server) => server.close()));
+});
+describe("managed MCP Streamable HTTP client", () => {
+    it("performs initialize, tools/list, and tools/call without authentication", async () => {
+        const server = await startMockMcpServer();
+        servers.push(server);
+        const client = await createManagedMcpClient({
+            transport: "streamable_http",
+            url: `${server.origin}/mcp`,
+            network: { allowedOrigins: [server.origin] },
+            credentials: resolveMcpHttpCredentials({}),
+            startupTimeoutMs: 1_000,
+            toolTimeoutMs: 1_000,
+        });
+        clients.push(client);
+        await expect(client.discoverTools()).resolves.toEqual([
+            expect.objectContaining({ name: "echo" }),
+        ]);
+        await expect(client.callTool("echo", { value: "hello" })).resolves.toMatchObject({
+            structuredContent: { echoed: "hello" },
+        });
+        expect(server.requests.map((request) => request.method)).toEqual([
+            "initialize",
+            "notifications/initialized",
+            "tools/list",
+            "tools/call",
+        ]);
+    });
+    it("injects one Bearer source and refreshes at most once after 401", async () => {
+        const server = await startMockMcpServer({ refreshBearer: "fresh-token" });
+        servers.push(server);
+        let token = "expired-token";
+        let refreshes = 0;
+        const client = await createManagedMcpClient({
+            transport: "streamable_http",
+            url: `${server.origin}/mcp`,
+            network: { allowedOrigins: [server.origin] },
+            credentials: resolveMcpHttpCredentials({
+                oauth: {
+                    token: async () => token,
+                    refresh: async () => {
+                        refreshes += 1;
+                        token = "fresh-token";
+                    },
+                },
+            }),
+            startupTimeoutMs: 1_000,
+            toolTimeoutMs: 1_000,
+        });
+        clients.push(client);
+        await expect(client.discoverTools()).resolves.toHaveLength(1);
+        expect(refreshes).toBe(1);
+        expect(server.requests.filter((request) => request.method === "initialize")).toHaveLength(2);
+        expect(server.requests.at(-1)?.authorization).toBe("Bearer fresh-token");
+    });
+    it("preserves the receiver for stateful OAuth credentials", async () => {
+        const oauth = {
+            currentToken: "stateful-token",
+            async token() {
+                return this.currentToken;
+            },
+            async refresh() { },
+        };
+        const credentials = resolveMcpHttpCredentials({ oauth });
+        await expect(credentials.authProvider?.token()).resolves.toBe("stateful-token");
+    });
+    it("refreshes only once and surfaces persistent upstream 401 responses", async () => {
+        const server = await startMockMcpServer({ alwaysUnauthorized: true });
+        servers.push(server);
+        let refreshes = 0;
+        let reauthorizationTransitions = 0;
+        await expect(createManagedMcpClient({
+            transport: "streamable_http",
+            url: `${server.origin}/mcp`,
+            network: { allowedOrigins: [server.origin] },
+            credentials: resolveMcpHttpCredentials({
+                oauth: {
+                    token: async () => "always-rejected",
+                    refresh: async () => {
+                        refreshes += 1;
+                    },
+                    markNeedsReauth: async () => {
+                        reauthorizationTransitions += 1;
+                    },
+                },
+            }),
+            startupTimeoutMs: 1_000,
+            toolTimeoutMs: 1_000,
+        })).rejects.toMatchObject({ code: "mcp_upstream_unauthorized" });
+        expect(refreshes).toBe(1);
+        expect(reauthorizationTransitions).toBe(1);
+        expect(server.requests.filter((request) => request.method === "initialize")).toHaveLength(2);
+    });
+    it("follows only policy-validated redirects and surfaces rate limits safely", async () => {
+        const redirecting = await startMockMcpServer({ redirectOnce: true });
+        servers.push(redirecting);
+        const redirectedClient = await createManagedMcpClient({
+            transport: "streamable_http",
+            url: `${redirecting.origin}/redirect`,
+            network: { allowedOrigins: [redirecting.origin] },
+            credentials: resolveMcpHttpCredentials({ bearerToken: "redirect-secret" }),
+            startupTimeoutMs: 1_000,
+            toolTimeoutMs: 1_000,
+        });
+        clients.push(redirectedClient);
+        await expect(redirectedClient.discoverTools()).resolves.toHaveLength(1);
+        const limited = await startMockMcpServer({ rateLimitTools: true });
+        servers.push(limited);
+        const limitedClient = await createManagedMcpClient({
+            transport: "streamable_http",
+            url: `${limited.origin}/mcp`,
+            network: { allowedOrigins: [limited.origin] },
+            credentials: resolveMcpHttpCredentials({}),
+            startupTimeoutMs: 1_000,
+            toolTimeoutMs: 1_000,
+        });
+        clients.push(limitedClient);
+        await expect(limitedClient.discoverTools()).rejects.toMatchObject({
+            code: "mcp_upstream_rate_limited",
+        });
+    });
+    it("rejects conflicting Authorization sources without exposing their values", () => {
+        expect(() => resolveMcpHttpCredentials({
+            bearerToken: "first-secret",
+            authorizationHeader: "Bearer second-secret",
+        })).toThrowError(expect.not.stringMatching(/first-secret|second-secret/));
+    });
+});
+describe("managed MCP STDIO client", () => {
+    it("uses canonical authenticated paths, selects environment, and force-reaps a stubborn child", async () => {
+        const fixtureRoot = await mkdtemp(path.join(os.tmpdir(), "rudder-mcp-stdio-"));
+        const canonicalCwd = path.join(fixtureRoot, "canonical-cwd");
+        const cwdAlias = path.join(fixtureRoot, "cwd-alias");
+        const commandAlias = path.join(fixtureRoot, "node-alias");
+        await mkdir(canonicalCwd);
+        await symlink(canonicalCwd, cwdAlias, "dir");
+        await symlink(process.execPath, commandAlias, "file");
+        const touchedPath = path.join(canonicalCwd, "must-not-exist");
+        const shellText = `$(touch ${touchedPath})`;
+        const fixturePath = fileURLToPath(new URL("./__fixtures__/stdio-server.mjs", import.meta.url));
+        const client = await createManagedMcpClient({
+            transport: "stdio",
+            command: commandAlias,
+            args: [fixturePath, shellText],
+            cwd: cwdAlias,
+            staticEnv: {
+                STATIC_ENV: "static-value",
+                STUBBORN_MODE: "1",
+            },
+            forwardedEnv: ["FORWARDED_ENV"],
+            secretEnv: { SECRET_ENV: "secret-value" },
+            hostEnv: {
+                FORWARDED_ENV: "forwarded-value",
+                UNSELECTED_SECRET: "must-not-leak",
+            },
+            deploymentPolicy: {
+                deploymentMode: "authenticated",
+                stdioCommands: [[commandAlias, fixturePath, shellText]],
+                stdioWorkingDirectories: [cwdAlias],
+                stdioEnvironmentNames: [
+                    "STATIC_ENV",
+                    "STUBBORN_MODE",
+                    "FORWARDED_ENV",
+                    "SECRET_ENV",
+                ],
+            },
+            startupTimeoutMs: 1_000,
+            toolTimeoutMs: 1_000,
+            maxOutputBytes: 128 * 1024,
+        });
+        clients.push(client);
+        const result = await client.callTool("inspect", {});
+        const details = result.structuredContent;
+        expect(details).toMatchObject({
+            argv0: await realpath(process.execPath),
+            cwd: await realpath(canonicalCwd),
+            extraArg: shellText,
+            staticEnv: "static-value",
+            forwardedEnv: "forwarded-value",
+            secretEnv: "secret-value",
+            unselectedEnv: null,
+            inheritedHome: null,
+        });
+        await expect(stat(touchedPath)).rejects.toMatchObject({ code: "ENOENT" });
+        const pid = details.pid;
+        const closeStartedAt = Date.now();
+        const firstClose = client.close();
+        let secondCloseObservedLiveChild = false;
+        const secondClose = client.close().then(() => {
+            try {
+                process.kill(pid, 0);
+                secondCloseObservedLiveChild = true;
+            }
+            catch {
+                secondCloseObservedLiveChild = false;
+            }
+        });
+        await Promise.all([firstClose, secondClose]);
+        clients.splice(clients.indexOf(client), 1);
+        expect(secondCloseObservedLiveChild).toBe(false);
+        expect(Date.now() - closeStartedAt).toBeLessThan(5_500);
+        expect(() => process.kill(pid, 0)).toThrow();
+    });
+    it("enforces tool timeout with redacted errors", async () => {
+        const fixturePath = fileURLToPath(new URL("./__fixtures__/stdio-server.mjs", import.meta.url));
+        const client = await createManagedMcpClient({
+            transport: "stdio",
+            command: process.execPath,
+            args: [fixturePath],
+            staticEnv: {},
+            forwardedEnv: [],
+            secretEnv: { SELECTED_ENV: "server-secret" },
+            hostEnv: {},
+            deploymentPolicy: {
+                deploymentMode: "local_trusted",
+                stdioCommands: [],
+                stdioWorkingDirectories: [],
+                stdioEnvironmentNames: [],
+            },
+            startupTimeoutMs: 1_000,
+            toolTimeoutMs: 25,
+            maxOutputBytes: 2_048,
+        });
+        clients.push(client);
+        await expect(client.callTool("sleep", { delayMs: 100 })).rejects.toMatchObject({
+            code: "mcp_tool_timeout",
+        });
+    });
+    it("returns a specific output-boundary error and reaps the child", async () => {
+        const fixturePath = fileURLToPath(new URL("./__fixtures__/stdio-server.mjs", import.meta.url));
+        const client = await createManagedMcpClient({
+            transport: "stdio",
+            command: process.execPath,
+            args: [fixturePath],
+            staticEnv: {},
+            forwardedEnv: [],
+            secretEnv: { SECRET_ENV: "server-secret" },
+            hostEnv: {},
+            deploymentPolicy: {
+                deploymentMode: "local_trusted",
+                stdioCommands: [],
+                stdioWorkingDirectories: [],
+                stdioEnvironmentNames: [],
+            },
+            startupTimeoutMs: 1_000,
+            toolTimeoutMs: 1_000,
+            maxOutputBytes: 2_048,
+        });
+        clients.push(client);
+        const inspected = await client.callTool("inspect", {});
+        const pid = inspected.structuredContent.pid;
+        const largeError = await client.callTool("large", { bytes: 8_192 }).then(() => null, (error) => error);
+        await client.close();
+        clients.splice(clients.indexOf(client), 1);
+        expect(largeError).toMatchObject({ code: "mcp_result_too_large" });
+        expect(JSON.stringify(largeError)).not.toContain("server-secret");
+        expect(() => process.kill(pid, 0)).toThrow();
+    });
+    it("rejects forged resolved credentials at the true client boundary", async () => {
+        const server = await startMockMcpServer();
+        servers.push(server);
+        const forgedCredentials = [
+            {
+                headers: { Authorization: "Bearer manual-secret" },
+                authProvider: { token: async () => "oauth-secret" },
+            },
+            { headers: { Cookie: "cookie-secret" } },
+            { headers: { Host: "host-secret" } },
+            { headers: { "Proxy-Authorization": "proxy-secret" } },
+        ];
+        for (const forged of forgedCredentials) {
+            await expect(createManagedMcpClient({
+                transport: "streamable_http",
+                url: `${server.origin}/mcp`,
+                network: { allowedOrigins: [server.origin] },
+                credentials: forged,
+                startupTimeoutMs: 1_000,
+                toolTimeoutMs: 1_000,
+            })).rejects.toSatisfy((error) => (!/manual-secret|oauth-secret|cookie-secret|host-secret|proxy-secret/u
+                .test(JSON.stringify(error))));
+        }
+        expect(server.requests).toHaveLength(0);
+    });
+});
+//# sourceMappingURL=managed-client.test.js.map