Files
reverse-engineering-anything/src/server/http/serveStreamableHttp.test.ts
T

1003 lines
33 KiB
TypeScript

import {
Client,
StreamableHTTPClientTransport,
} from "@modelcontextprotocol/client";
import { WebStandardStreamableHTTPServerTransport } from "@modelcontextprotocol/server";
import { Agent, request as httpRequest } from "node:http";
import pino from "pino";
import { afterEach, expect, it, vi } from "vitest";
import { z } from "zod";
import {
expectForeignHostRefused,
rawHttpRequest,
} from "../../../tests/support/http/rawRequest.js";
import {
hostHeaderAllowlist,
McpSessionSlot,
serveStreamableHttp,
type StreamableHttpServer,
} from "./serveStreamableHttp.js";
import { StreamableHttpListenError } from "./streamableHttpListenError.js";
import { RequestTrackingMcpServer } from "../RequestTrackingMcpServer.js";
const servers: StreamableHttpServer[] = [];
afterEach(async () => {
await Promise.all(servers.splice(0).map((server) => server.close()));
});
/** An echo server whose protocol onclose hook counts as a shutdown, as rea's provider cleanup does. */
const createEchoServer = (onShutdown: () => void): RequestTrackingMcpServer => {
const server = new RequestTrackingMcpServer({
name: "echo-fixture",
version: "1",
});
server.registerTool(
"echo",
{ description: "Echo text", inputSchema: z.object({ text: z.string() }) },
({ text }) => ({ content: [{ type: "text", text }] }),
);
server.server.onclose = onShutdown;
return server;
};
const start = async (
overrides: Partial<Parameters<typeof serveStreamableHttp>[0]> = {},
) => {
const logs: string[] = [];
const logger = pino({ level: "debug" }, { write: (line) => logs.push(line) });
let factoryCalls = 0;
let shutdownHooks = 0;
const served = await serveStreamableHttp({
host: "127.0.0.1",
port: 0,
createMcpServer: () => {
factoryCalls += 1;
return createEchoServer(() => {
shutdownHooks += 1;
});
},
logger,
...overrides,
});
servers.push(served);
return {
served,
messages: () =>
logs.map((line) => (JSON.parse(line) as { msg: string }).msg),
entries: () =>
logs.map((line) => JSON.parse(line) as Record<string, unknown>),
factoryCalls: () => factoryCalls,
shutdownHooks: () => shutdownHooks,
};
};
const connect = async (url: string) => {
const transport = new StreamableHTTPClientTransport(new URL(url));
const client = new Client({ name: "streamable-http-adapter", version: "1" });
await client.connect(transport);
return { transport, client };
};
const echo = async (client: Client, text: string): Promise<unknown> => {
const result = await client.callTool({ name: "echo", arguments: { text } });
return result.content;
};
/** One keep-alive request; reports whether the server closed the socket after the reply. */
const keepAliveRequest = (
agent: Agent,
url: URL,
options: {
readonly method: string;
readonly headers?: Readonly<Record<string, string>>;
readonly body?: string;
},
): Promise<{
status: number;
headers: Record<string, string | string[] | undefined>;
socketClosed: boolean;
}> =>
new Promise((resolve, reject) => {
const request = httpRequest(
url,
{ method: options.method, headers: { ...options.headers }, agent },
(response) => {
const socket = response.socket;
let closed = false;
socket?.once("close", () => {
closed = true;
});
response.resume();
response.once("end", () => {
// Give a closing server one turn to end the socket after the reply.
setTimeout(
() =>
resolve({
status: response.statusCode ?? 0,
headers: response.headers,
socketClosed: closed || (socket?.destroyed ?? false),
}),
50,
);
});
response.once("error", reject);
},
);
request.once("error", reject);
request.end(options.body);
});
/** A new client's initialize as the bridge hands it to the slot: no session id yet. */
const initializeRequest = (): Request =>
new Request("http://127.0.0.1/mcp", {
method: "POST",
headers: {
accept: "application/json, text/event-stream",
"content-type": "application/json",
},
body: JSON.stringify({
jsonrpc: "2.0",
id: 1,
method: "initialize",
params: {
protocolVersion: "2025-11-25",
capabilities: {},
clientInfo: { name: "racing-client", version: "1" },
},
}),
});
it("announces the bound URL and serves one session at a time on one live instance", async () => {
const { served, entries, messages, factoryCalls, shutdownHooks } =
await start();
expect(new URL(served.url).pathname).toBe("/mcp");
expect(entries()).toContainEqual(
expect.objectContaining({
transport: "streamable-http",
url: served.url,
msg: "MCP transport listening",
}),
);
const first = await connect(served.url);
const sessionId = first.transport.sessionId;
expect(sessionId).toEqual(expect.any(String));
await expect(echo(first.client, "hi")).resolves.toEqual([
{ type: "text", text: "hi" },
]);
// A new client's initialize replaces the open session; the earlier client is refused.
const second = await connect(served.url);
expect(second.transport.sessionId).toEqual(expect.any(String));
expect(second.transport.sessionId).not.toBe(sessionId);
await expect(echo(first.client, "stale")).rejects.toThrow();
await expect(echo(second.client, "live")).resolves.toEqual([
{ type: "text", text: "live" },
]);
await first.client.close();
// DELETE ends the session, not the server: the instance keeps serving.
await second.transport.terminateSession();
expect(second.transport.sessionId).toBeUndefined();
await second.client.close();
const third = await connect(served.url);
await expect(echo(third.client, "again")).resolves.toEqual([
{ type: "text", text: "again" },
]);
expect(factoryCalls()).toBe(1);
expect(shutdownHooks()).toBe(0);
expect(
messages().filter((msg) => msg === "MCP HTTP session opened"),
).toHaveLength(3);
expect(messages()).toContain("MCP HTTP session replaced by a new client");
// Closing the listener with a session open is the shutdown the instance's hook waits for.
await served.close();
expect(shutdownHooks()).toBe(1);
await third.client.close();
});
it("keeps the instance's shutdown hook when two initialize requests race to replace an open session", async () => {
let shutdownHooks = 0;
const slot = new McpSessionSlot(
createEchoServer(() => {
shutdownHooks += 1;
}),
undefined,
);
const opened = await slot.handle(initializeRequest());
expect(opened.status).toBe(200);
// Both requests see the same open session and end it in lockstep.
const raced = await Promise.all([
slot.handle(initializeRequest()),
slot.handle(initializeRequest()),
]);
expect(raced.map((response) => response.status).sort()).toEqual([200, 400]);
const winner = raced.find((response) => response.status === 200);
expect(winner?.headers.get("mcp-session-id")).toEqual(expect.any(String));
expect(shutdownHooks).toBe(0);
// Only the slot's own close is the shutdown the instance's hook waits for.
await slot.close();
expect(shutdownHooks).toBe(1);
});
it("serves plain routes beside the MCP endpoint and answers unknown paths with 404", async () => {
const { served } = await start({
routes: [
{
method: "GET",
path: "/.well-known/probe",
handle: () => Response.json({ probe: true }),
},
],
});
const probe = await fetch(new URL("/.well-known/probe", served.url));
await expect(probe.json()).resolves.toEqual({ probe: true });
const missing = await fetch(new URL("/missing", served.url));
expect(missing.status).toBe(404);
await expect(missing.json()).resolves.toMatchObject({
error: { code: -32601 },
});
const wrongMethod = await fetch(new URL("/.well-known/probe", served.url), {
method: "POST",
body: "{}",
});
expect(wrongMethod.status).toBe(404);
});
it("refuses foreign Host headers on a loopback bind and frees the port on close", async () => {
const { served } = await start();
const url = new URL(served.url);
await expectForeignHostRefused(url);
await served.close();
await served.close();
await expect(rawHttpRequest(url)).rejects.toMatchObject({
code: "ECONNREFUSED",
});
});
it("reports a port that cannot be bound as a typed listen error naming the cause", async () => {
const { served } = await start();
const failed = serveStreamableHttp({
host: "127.0.0.1",
port: Number(new URL(served.url).port),
createMcpServer: () => createEchoServer(() => undefined),
});
await expect(failed).rejects.toBeInstanceOf(StreamableHttpListenError);
await expect(failed).rejects.toThrow(/EADDRINUSE/u);
});
it("keeps the SDK loopback allowlist, plus the bind's own hostname, for every loopback spelling", () => {
const sdk = ["localhost", "127.0.0.1", "[::1]"];
expect(hostHeaderAllowlist("127.0.0.1")).toEqual(sdk);
expect(hostHeaderAllowlist("localhost")).toEqual(sdk);
expect(hostHeaderAllowlist("LOCALHOST")).toEqual(sdk);
expect(hostHeaderAllowlist("::1")).toEqual(sdk);
expect(hostHeaderAllowlist("0:0:0:0:0:0:0:1")).toEqual(sdk);
expect(hostHeaderAllowlist("127.0.0.2")).toEqual([...sdk, "127.0.0.2"]);
expect(hostHeaderAllowlist("localhost.")).toEqual([...sdk, "localhost."]);
expect(hostHeaderAllowlist("::ffff:127.0.0.1")).toEqual([
...sdk,
"[::ffff:7f00:1]",
]);
expect(hostHeaderAllowlist("192.0.2.10")).toBeUndefined();
expect(hostHeaderAllowlist("0.0.0.0")).toBeUndefined();
expect(hostHeaderAllowlist("::")).toBeUndefined();
expect(hostHeaderAllowlist("example.com")).toBeUndefined();
expect(hostHeaderAllowlist("not a host")).toBeUndefined();
});
it("refuses requests once the slot is closed and joins an initialize that is still arming", async () => {
let shutdowns = 0;
const slot = new McpSessionSlot(
createEchoServer(() => {
shutdowns += 1;
}),
undefined,
);
const arming = slot.handle(initializeRequest());
await slot.close();
expect((await arming).status).toBe(503);
expect(shutdowns).toBe(1);
expect((await slot.handle(initializeRequest())).status).toBe(503);
});
it("retries unfinished cleanup after a close stage fails instead of replaying the failure", async () => {
let failures = 1;
const { served } = await start({
createMcpServer: () => {
const server = createEchoServer(() => undefined);
const original = server.close.bind(server);
server.close = async () => {
if (failures > 0) {
failures -= 1;
throw new Error("provider cleanup failed");
}
await original();
};
return server;
},
});
await expect(served.close()).rejects.toThrow("provider cleanup failed");
await expect(served.close()).resolves.toBeUndefined();
await expect(rawHttpRequest(new URL(served.url))).rejects.toMatchObject({
code: "ECONNREFUSED",
});
});
it("leaves a sessionless POST without the streamable headers or with a foreign Origin to refusal, keeping the session", async () => {
const { served } = await start();
const { client } = await connect(served.url);
const url = new URL(served.url);
const body = await initializeRequest().text();
const host = `127.0.0.1:${url.port}`;
const plain = await rawHttpRequest(url, {
method: "POST",
headers: {
host,
"content-type": "text/plain",
accept: "application/json, text/event-stream",
},
body,
});
expect(plain.status).toBeGreaterThanOrEqual(400);
expect(plain.status).toBeLessThan(500);
const foreign = await rawHttpRequest(url, {
method: "POST",
headers: {
host,
origin: "http://attacker.example",
"content-type": "application/json",
accept: "application/json, text/event-stream",
},
body,
});
expect(foreign.status).toBe(403);
expect(await echo(client, "still here")).toEqual([
{ type: "text", text: "still here" },
]);
await client.close();
});
it("accepts a same-origin browser Origin carrying the bound port on the MCP endpoint and on routes", async () => {
const { served } = await start({
routes: [
{ method: "GET", path: "/health", handle: () => new Response("ok") },
],
});
const url = new URL(served.url);
const body = await initializeRequest().text();
for (const name of ["127.0.0.1", "localhost"]) {
const headers = {
host: `${name}:${url.port}`,
origin: `http://${name}:${url.port}`,
};
const route = await rawHttpRequest(new URL("/health", url), { headers });
expect(route.status).toBe(200);
const initialize = await rawHttpRequest(url, {
method: "POST",
headers: {
...headers,
"content-type": "application/json",
accept: "application/json, text/event-stream",
},
body,
});
expect(initialize.status).toBe(200);
}
});
it("announces the bound URL even when the log level hides info lines", async () => {
const logs: string[] = [];
const logger = pino({ level: "warn" }, { write: (line) => logs.push(line) });
const { served } = await start({ logger });
expect(
logs.map((line) => JSON.parse(line) as Record<string, unknown>),
).toContainEqual(
expect.objectContaining({
msg: "MCP transport listening",
url: served.url,
}),
);
});
it("does not let a JSON-suffixed media type replace the session", async () => {
const { served } = await start();
const { client } = await connect(served.url);
const url = new URL(served.url);
const patch = await rawHttpRequest(url, {
method: "POST",
headers: {
host: `127.0.0.1:${url.port}`,
"content-type": "application/json-patch+json",
accept: "application/json, text/event-stream",
},
body: await initializeRequest().text(),
});
expect(patch.status).toBeGreaterThanOrEqual(400);
expect(patch.status).toBeLessThan(500);
expect(await echo(client, "unchanged")).toEqual([
{ type: "text", text: "unchanged" },
]);
await client.close();
});
it("releases the listener when the server factory fails after the port is bound", async () => {
const logs: string[] = [];
const logger = pino({ level: "debug" }, { write: (line) => logs.push(line) });
const seen: string[] = [];
const failing = serveStreamableHttp({
host: "127.0.0.1",
port: 0,
logger,
createMcpServer: () => {
throw new Error("provider unavailable");
},
});
await expect(failing).rejects.toThrow("provider unavailable");
for (const line of logs) seen.push((JSON.parse(line) as { msg: string }).msg);
expect(seen).not.toContain("MCP transport listening");
});
it("classifies loopback from the bound address and lists the configured name beside it", () => {
const sdk = ["localhost", "127.0.0.1", "[::1]"];
expect(hostHeaderAllowlist("ip6-localhost", "::1")).toEqual([
...sdk,
"ip6-localhost",
]);
expect(hostHeaderAllowlist("dev.local", "127.0.0.1")).toEqual([
...sdk,
"dev.local",
]);
expect(hostHeaderAllowlist("0.0.0.0", "0.0.0.0")).toBeUndefined();
expect(hostHeaderAllowlist("dev.local", "192.0.2.10")).toBeUndefined();
});
it("refuses a scoped IPv6 bind before creating anything and keeps bind failures away from onerror", async () => {
let factoryCalls = 0;
const onerror = (): void => {
throw new Error("onerror must not run during startup");
};
await expect(
serveStreamableHttp({
host: "fe80::1%lo0",
port: 0,
onerror,
createMcpServer: () => {
factoryCalls += 1;
return createEchoServer(() => undefined);
},
}),
).rejects.toBeInstanceOf(StreamableHttpListenError);
expect(factoryCalls).toBe(0);
const { served } = await start();
await expect(
serveStreamableHttp({
host: "127.0.0.1",
port: Number(new URL(served.url).port),
onerror,
createMcpServer: () => createEchoServer(() => undefined),
}),
).rejects.toThrow(/EADDRINUSE/u);
});
it("leaves the instance to its owner when closeInstance is false", async () => {
let instanceCloses = 0;
const server = createEchoServer(() => undefined);
const original = server.close.bind(server);
server.close = async () => {
instanceCloses += 1;
await original();
};
const served = await serveStreamableHttp({
host: "127.0.0.1",
port: 0,
closeInstance: false,
createMcpServer: () => server,
});
await served.close();
expect(instanceCloses).toBe(0);
await server.close();
expect(instanceCloses).toBe(1);
});
it("requires exact Accept media ranges before a sessionless POST may replace the session", async () => {
const { served } = await start();
const { client } = await connect(served.url);
const url = new URL(served.url);
const lookalike = await rawHttpRequest(url, {
method: "POST",
headers: {
host: `127.0.0.1:${url.port}`,
"content-type": "application/json",
accept: "application/json-patch+json, text/event-streaming",
},
body: await initializeRequest().text(),
});
expect(lookalike.status).toBeGreaterThanOrEqual(400);
expect(lookalike.status).toBeLessThan(500);
expect(await echo(client, "still mine")).toEqual([
{ type: "text", text: "still mine" },
]);
await client.close();
});
it("keeps the live session when the new client left before its initialize was probed", async () => {
const slot = new McpSessionSlot(
createEchoServer(() => undefined),
undefined,
);
const close = vi.spyOn(
WebStandardStreamableHTTPServerTransport.prototype,
"close",
);
try {
expect((await slot.handle(initializeRequest())).status).toBe(200);
const left = new AbortController();
left.abort();
const abandoned = new Request(initializeRequest(), { signal: left.signal });
expect((await slot.handle(abandoned)).status).toBe(400);
expect(close).not.toHaveBeenCalled();
expect((await slot.handle(initializeRequest())).status).toBe(200);
expect(close).toHaveBeenCalledTimes(1);
} finally {
close.mockRestore();
await slot.close();
}
});
it("keeps a session whose transport shutdown failed so the next close retries it", async () => {
let shutdowns = 0;
const slot = new McpSessionSlot(
createEchoServer(() => {
shutdowns += 1;
}),
undefined,
);
// The slot binds the transport's close when it arms, so the spy must exist before the first request.
const close = vi
.spyOn(WebStandardStreamableHTTPServerTransport.prototype, "close")
.mockImplementationOnce(() => Promise.reject(new Error("transport stuck")));
try {
await slot.handle(initializeRequest());
await expect(slot.close()).rejects.toThrow("transport stuck");
expect(shutdowns).toBe(0);
await expect(slot.close()).resolves.toBeUndefined();
expect(shutdowns).toBe(1);
expect((await slot.handle(initializeRequest())).status).toBe(503);
} finally {
close.mockRestore();
}
});
it("runs the instance's shutdown hook exactly once when the slot closes without a live session", async () => {
let hooks = 0;
const slot = new McpSessionSlot(
createEchoServer(() => {
hooks += 1;
}),
undefined,
);
await slot.close();
await slot.close();
expect(hooks).toBe(1);
const { served, shutdownHooks } = await start();
await served.close();
expect(shutdownHooks()).toBe(1);
});
it("answers an oversized sessionless POST promptly instead of stalling on the probe", async () => {
const { served } = await start();
const { client } = await connect(served.url);
const url = new URL(served.url);
// The SDK refuses the body as soon as it exceeds the bound, so the upload may end in a broken pipe.
await rawHttpRequest(url, {
method: "POST",
headers: {
host: `127.0.0.1:${url.port}`,
"content-type": "application/json",
accept: "application/json, text/event-stream",
},
body: `{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"pad":"${"x".repeat(4_500_000)}"}}`,
}).then(
(refused) => {
expect(refused.status).toBeGreaterThanOrEqual(400);
expect(refused.status).toBeLessThan(500);
},
(cause: unknown) => {
expect(["EPIPE", "ECONNRESET"]).toContain(
(cause as { code?: string }).code,
);
},
);
expect(await echo(client, "still served")).toEqual([
{ type: "text", text: "still served" },
]);
await client.close();
}, 20_000);
it("closes the connection after a reply sent before the request body was read, on a keep-alive client", async () => {
const { served } = await start();
const url = new URL(served.url);
const agent = new Agent({ keepAlive: true, maxSockets: 1 });
try {
const unread = await keepAliveRequest(agent, new URL("/nowhere", url), {
method: "POST",
headers: { "content-type": "application/json" },
body: '{"never":"read"}',
});
expect(unread.status).toBe(404);
expect(unread.headers.connection).toBe("close");
expect(unread.socketClosed).toBe(true);
// Node's parser refuses a chunked GET body itself; a declared Content-Length reaches the bridge.
const bodyOnGet = await keepAliveRequest(agent, new URL("/nowhere", url), {
method: "GET",
headers: { "content-type": "text/plain", "content-length": "15" },
body: "a body on a GET",
});
expect(bodyOnGet.status).toBe(404);
expect(bodyOnGet.headers.connection).toBe("close");
expect(bodyOnGet.socketClosed).toBe(true);
const bodiless = await keepAliveRequest(agent, new URL("/nowhere", url), {
method: "GET",
});
expect(bodiless.status).toBe(404);
expect(bodiless.headers.connection).not.toBe("close");
expect(bodiless.socketClosed).toBe(false);
} finally {
agent.destroy();
}
});
it("answers a method Fetch refuses instead of letting it escape the request guard", async () => {
const { served } = await start();
const url = new URL(served.url);
const trace = await rawHttpRequest(url, {
method: "TRACE",
headers: { host: `127.0.0.1:${url.port}` },
});
expect(trace.status).toBe(405);
expect(trace.headers.connection).toBe("close");
const { client } = await connect(served.url);
expect(await echo(client, "still alive")).toEqual([
{ type: "text", text: "still alive" },
]);
await client.close();
});
/** One request with a caller-controlled request target, which URL-based clients normalize away. */
const rawTargetRequest = (
served: URL,
target: string,
): Promise<{ status: number; body: string }> =>
new Promise((resolve, reject) => {
const request = httpRequest(
{
host: served.hostname,
port: Number(served.port),
path: target,
method: "GET",
agent: false,
headers: { host: `127.0.0.1:${served.port}` },
},
(response) => {
let body = "";
response.setEncoding("utf8");
response.on("data", (chunk: string) => {
body += chunk;
});
response.on("end", () =>
resolve({ status: response.statusCode ?? 0, body }),
);
},
);
request.on("error", reject);
request.end();
});
it("keeps a network-path request target as a path and refuses absolute-form targets", async () => {
const seen: string[] = [];
const { served } = await start({
routes: [
{
method: "GET",
path: "/card",
handle: (request) => {
seen.push(new URL(request.url).host);
return Response.json({ ok: true });
},
},
],
});
const url = new URL(served.url);
const networkPath = await rawTargetRequest(url, "//attacker.example/card");
expect(networkPath.status).toBe(404);
expect(networkPath.body).toContain(
"No route for GET //attacker.example/card",
);
const absolute = await rawTargetRequest(url, "http://attacker.example/card");
expect(absolute.status).toBe(400);
// Dot segments would route a different path than the one requested; they are refused, not canonicalized.
for (const target of ["/public/../mcp", "/public/%2e%2e/mcp", "/./mcp"])
expect((await rawTargetRequest(url, target)).status).toBe(400);
expect((await rawTargetRequest(url, "/card?x=1")).status).toBe(200);
const plain = await rawTargetRequest(url, "/card");
expect(plain.status).toBe(200);
// Both successful route calls saw only the bound host, never the attacker-selected one.
expect(seen).toEqual([`127.0.0.1:${url.port}`, `127.0.0.1:${url.port}`]);
});
it("lets only a lone initialize replace a session, not a batch that carries one", async () => {
const { served } = await start();
const { client } = await connect(served.url);
const url = new URL(served.url);
const single = JSON.parse(await initializeRequest().text()) as unknown;
const batch = await rawHttpRequest(url, {
method: "POST",
headers: {
host: `127.0.0.1:${url.port}`,
"content-type": "application/json",
accept: "application/json, text/event-stream",
},
body: JSON.stringify([
single,
{ jsonrpc: "2.0", method: "notifications/initialized" },
]),
});
expect(batch.status).toBeGreaterThanOrEqual(400);
expect(batch.status).toBeLessThan(500);
expect(await echo(client, "not evicted")).toEqual([
{ type: "text", text: "not evicted" },
]);
await client.close();
});
it("retries a shutdown hook that threw instead of marking it complete", async () => {
let attempts = 0;
const slot = new McpSessionSlot(
createEchoServer(() => {
attempts += 1;
if (attempts === 1) throw new Error("hook failed once");
}),
undefined,
);
await expect(slot.close()).rejects.toThrow("hook failed once");
await expect(slot.close()).resolves.toBeUndefined();
await slot.close();
expect(attempts).toBe(2);
});
it("closes the connection when a route read only part of the body and keeps it after a full read", async () => {
const { served } = await start({
routes: [
{
method: "POST",
path: "/partial",
handle: async (request) => {
const reader = request.body?.getReader();
await reader?.read();
return new Response("stopped early");
},
},
{
method: "POST",
path: "/whole",
handle: async (request) =>
Response.json({ bytes: (await request.text()).length }),
},
],
});
const url = new URL(served.url);
const agent = new Agent({ keepAlive: true, maxSockets: 1 });
const body = "x".repeat(256 * 1024);
try {
const partial = await keepAliveRequest(agent, new URL("/partial", url), {
method: "POST",
headers: {
"content-type": "text/plain",
"content-length": String(body.length),
},
body,
});
expect(partial.status).toBe(200);
expect(partial.headers.connection).toBe("close");
expect(partial.socketClosed).toBe(true);
const whole = await keepAliveRequest(agent, new URL("/whole", url), {
method: "POST",
headers: {
"content-type": "text/plain",
"content-length": String(body.length),
},
body,
});
expect(whole.status).toBe(200);
expect(whole.headers.connection).not.toBe("close");
expect(whole.socketClosed).toBe(false);
} finally {
agent.destroy();
}
});
it("does not let a zero-quality, quoted or SDK-refused Accept qualify a session takeover", async () => {
const { served } = await start();
const { client } = await connect(served.url);
const url = new URL(served.url);
// The second header holds one range: the comma and `text/event-stream` sit inside a quoted parameter.
// The third is valid HTTP, but the SDK matches media types with case and would answer 406.
for (const accept of [
"application/json;q=0, text/event-stream",
'application/json;note=", text/event-stream;x=1"',
"Application/JSON, Text/Event-Stream",
]) {
const refused = await rawHttpRequest(url, {
method: "POST",
headers: {
host: `127.0.0.1:${url.port}`,
"content-type": "application/json",
accept,
},
body: await initializeRequest().text(),
});
expect(refused.status).toBeGreaterThanOrEqual(400);
expect(refused.status).toBeLessThan(500);
}
expect(await echo(client, "kept")).toEqual([{ type: "text", text: "kept" }]);
await client.close();
});
it.each(["replacement", "DELETE"])(
"waits for a cancelled tool's finally block before reusing the instance after %s",
async (ending) => {
let release!: () => void;
let entered!: () => void;
let cancelled!: () => void;
const gate = new Promise<void>((resolve) => {
release = resolve;
});
const started = new Promise<void>((resolve) => {
entered = resolve;
});
const aborted = new Promise<void>((resolve) => {
cancelled = resolve;
});
let state = "initial";
let connections = 0;
const { served } = await start({
createMcpServer: () => {
const server = createEchoServer(() => undefined);
const connectServer = server.connect.bind(server);
server.connect = async (transport) => {
connections += 1;
await connectServer(transport);
};
server.registerTool(
"slow",
{ inputSchema: z.object({}) },
async (_args, context) => {
context.mcpReq.signal.addEventListener("abort", cancelled, {
once: true,
});
entered();
try {
await gate;
return { content: [] };
} finally {
state = "old-finally";
}
},
);
return server;
},
});
const first = await connect(served.url);
let next: Awaited<ReturnType<typeof connect>> | undefined;
let replacement: ReturnType<typeof connect> | undefined;
try {
void first.client
.callTool({ name: "slow", arguments: {} })
.catch(() => undefined);
await started;
const deletion =
ending === "DELETE" ? first.transport.terminateSession() : undefined;
if (deletion !== undefined) await aborted;
let connected = false;
replacement = connect(served.url).then((value) => {
connected = true;
next = value;
return value;
});
await aborted;
await new Promise<void>((resolve) => setImmediate(resolve));
expect(connections).toBe(1);
expect(connected).toBe(false);
expect(state).toBe("initial");
release();
await deletion;
const connectedNext = await replacement;
expect(state).toBe("old-finally");
await expect(echo(connectedNext.client, "new session")).resolves.toEqual([
{ type: "text", text: "new session" },
]);
} finally {
release();
await replacement?.catch(() => undefined);
await first.client.close();
await next?.client.close();
}
},
);
it.each(["after timeout", "during drain"])(
"automatically completes shutdown %s when the retained handler settles",
async (shutdownTiming) => {
let release!: () => void;
let entered!: () => void;
let draining!: () => void;
const gate = new Promise<void>((resolve) => {
release = resolve;
});
const started = new Promise<void>((resolve) => {
entered = resolve;
});
const drainStarted = new Promise<void>((resolve) => {
draining = resolve;
});
let shutdowns = 0;
const { served } = await start({
sessionDrainTimeoutMs: 0,
createMcpServer: () => {
const server = createEchoServer(() => {
shutdowns += 1;
});
const drain = server.drainToolCalls.bind(server);
vi.spyOn(server, "drainToolCalls").mockImplementation((timeoutMs) => {
const result = drain(timeoutMs);
draining();
return result;
});
server.registerTool("slow", { inputSchema: z.object({}) }, async () => {
entered();
await gate;
return { content: [] };
});
return server;
},
});
const first = await connect(served.url);
try {
void first.client
.callTool({ name: "slow", arguments: {} })
.catch(() => undefined);
await started;
const replacement = fetch(served.url, {
method: "POST",
headers: {
"content-type": "application/json",
accept: "application/json, text/event-stream",
},
body: await initializeRequest().text(),
}).catch((cause: unknown) => {
// Full shutdown closes listener sockets, including this pending handover.
if (shutdownTiming === "during drain") return undefined;
throw cause;
});
await drainStarted;
const pendingClose =
shutdownTiming === "during drain" ? served.close() : undefined;
const refused = await replacement;
if (shutdownTiming === "after timeout") expect(refused?.status).toBe(503);
let closed = false;
const closing = (pendingClose ?? served.close()).then(() => {
closed = true;
});
await new Promise<void>((resolve) => setImmediate(resolve));
expect(closed).toBe(false);
expect(shutdowns).toBe(0);
release();
await closing;
expect(shutdowns).toBe(1);
} finally {
release();
await first.client.close();
}
},
);