@zereight/mcp-gitlab 2.1.46 → 2.1.48

package/build/test/server/request-helpers.test.js

@@ -0,0 +1,38 @@
+import { describe, test } from "node:test";
+import assert from "node:assert";
+import { isInitializationRequestBody, isUnauthenticatedDiscoveryRequestBody, readAcceptHeader, readMcpSessionIdHeader, redactSessionIdForLog, } from "../../server/request-helpers.js";
+describe("streamable request helpers", () => {
+    test("redacts stateless session ids and truncates legacy ids", () => {
+        assert.strictEqual(redactSessionIdForLog(undefined), "<none>");
+        assert.strictEqual(redactSessionIdForLog("v1.sid.secret-payload"), "v1.sid.<redacted>");
+        assert.strictEqual(redactSessionIdForLog("123456789abcdef"), "12345678…");
+        assert.strictEqual(redactSessionIdForLog("short"), "short");
+    });
+    test("detects initialize requests in single and batch bodies", () => {
+        assert.strictEqual(isInitializationRequestBody({ method: "initialize" }), true);
+        assert.strictEqual(isInitializationRequestBody([{ method: "tools/list" }, { method: "initialize" }]), true);
+        assert.strictEqual(isInitializationRequestBody({ method: "tools/list" }), false);
+        assert.strictEqual(isInitializationRequestBody(null), false);
+    });
+    test("allows only discovery methods in unauthenticated discovery bodies", () => {
+        assert.strictEqual(isUnauthenticatedDiscoveryRequestBody({ method: "tools/list" }), true);
+        assert.strictEqual(isUnauthenticatedDiscoveryRequestBody([
+            { method: "initialize" },
+            { method: "notifications/initialized" },
+            { method: "tools/list" },
+        ]), true);
+        assert.strictEqual(isUnauthenticatedDiscoveryRequestBody([{ method: "tools/list" }, { method: "call_tool" }]), false);
+        assert.strictEqual(isUnauthenticatedDiscoveryRequestBody(undefined), false);
+    });
+    test("normalizes Mcp-Session-Id headers", () => {
+        assert.strictEqual(readMcpSessionIdHeader({ headers: { "mcp-session-id": "sid-1" } }), "sid-1");
+        assert.strictEqual(readMcpSessionIdHeader({ headers: { "mcp-session-id": "" } }), undefined);
+        assert.strictEqual(readMcpSessionIdHeader({ headers: { "mcp-session-id": ["sid-1", "sid-2"] } }), undefined);
+        assert.strictEqual(readMcpSessionIdHeader({ headers: {} }), undefined);
+    });
+    test("joins duplicate Accept headers so text/event-stream is not dropped", () => {
+        assert.strictEqual(readAcceptHeader({ headers: { accept: "application/json, text/event-stream" } }), "application/json, text/event-stream");
+        assert.strictEqual(readAcceptHeader({ headers: { accept: ["application/json", "text/event-stream"] } }), "application/json, text/event-stream");
+        assert.strictEqual(readAcceptHeader({ headers: {} }), "");
+    });
+});

package/build/test/stateless/callback-proxy.test.js

@@ -290,6 +290,83 @@ describe("callback-proxy cross-pod flow (stateless)", () => {
         const wrongVerifier = randomBytes(32).toString("base64url");
         await assert.rejects(() => pod.exchangeAuthorizationCode(registered, proxyCode, wrongVerifier, CLIENT_REDIRECT), /PKCE verification failed/);
     });
+    test("failed PKCE does not burn the code; legitimate exchange still succeeds", async () => {
+        const s = secret();
+        const pod = makeProvider(loadMaterial(s));
+        const registered = await pod.clientsStore.registerClient({
+            redirect_uris: [CLIENT_REDIRECT],
+            token_endpoint_auth_method: "none",
+        });
+        const correctVerifier = randomBytes(32).toString("base64url");
+        const correctChallenge = createHash("sha256")
+            .update(correctVerifier)
+            .digest("base64url");
+        const authorizeRes = makeAuthorizeRes();
+        await pod.authorize(registered, {
+            state: "s",
+            scopes: ["api"],
+            redirectUri: CLIENT_REDIRECT,
+            codeChallenge: correctChallenge,
+        }, authorizeRes);
+        const proxyState = new URL(authorizeRes.redirectedTo).searchParams.get("state");
+        const cbRes = makeFakeRes();
+        await pod.handleCallback(fakeReq({ code: "gitlab-code", state: proxyState }), cbRes);
+        const proxyCode = new URL(cbRes.redirectedTo).searchParams.get("code");
+        const wrongVerifier = randomBytes(32).toString("base64url");
+        await assert.rejects(() => pod.exchangeAuthorizationCode(registered, proxyCode, wrongVerifier, CLIENT_REDIRECT), /PKCE verification failed/);
+        const tokens = await pod.exchangeAuthorizationCode(registered, proxyCode, correctVerifier, CLIENT_REDIRECT);
+        assert.equal(tokens.access_token, "gl-access-123");
+    });
+    test("successful exchange then replay is rejected on the same pod", async () => {
+        const s = secret();
+        const pod = makeProvider(loadMaterial(s));
+        const registered = await pod.clientsStore.registerClient({
+            redirect_uris: [CLIENT_REDIRECT],
+            token_endpoint_auth_method: "none",
+        });
+        const verifier = randomBytes(32).toString("base64url");
+        const challenge = createHash("sha256").update(verifier).digest("base64url");
+        const authorizeRes = makeAuthorizeRes();
+        await pod.authorize(registered, {
+            state: "s",
+            scopes: ["api"],
+            redirectUri: CLIENT_REDIRECT,
+            codeChallenge: challenge,
+        }, authorizeRes);
+        const proxyState = new URL(authorizeRes.redirectedTo).searchParams.get("state");
+        const cbRes = makeFakeRes();
+        await pod.handleCallback(fakeReq({ code: "gitlab-code", state: proxyState }), cbRes);
+        const proxyCode = new URL(cbRes.redirectedTo).searchParams.get("code");
+        const tokens = await pod.exchangeAuthorizationCode(registered, proxyCode, verifier, CLIENT_REDIRECT);
+        assert.equal(tokens.access_token, "gl-access-123");
+        await assert.rejects(() => pod.exchangeAuthorizationCode(registered, proxyCode, verifier, CLIENT_REDIRECT), /Authorization code already used/);
+    });
+    test("exchangeAuthorizationCode reports busy when replay cache is full", async () => {
+        const s = secret();
+        const pod = makeProvider(loadMaterial(s));
+        const registered = await pod.clientsStore.registerClient({
+            redirect_uris: [CLIENT_REDIRECT],
+            token_endpoint_auth_method: "none",
+        });
+        const verifier = randomBytes(32).toString("base64url");
+        const challenge = createHash("sha256").update(verifier).digest("base64url");
+        const authorizeRes = makeAuthorizeRes();
+        await pod.authorize(registered, {
+            state: "s",
+            scopes: ["api"],
+            redirectUri: CLIENT_REDIRECT,
+            codeChallenge: challenge,
+        }, authorizeRes);
+        const proxyState = new URL(authorizeRes.redirectedTo).searchParams.get("state");
+        const cbRes = makeFakeRes();
+        await pod.handleCallback(fakeReq({ code: "gitlab-code", state: proxyState }), cbRes);
+        const proxyCode = new URL(cbRes.redirectedTo).searchParams.get("code");
+        const cache = pod._usedProxyCodes;
+        for (let i = 0; i < cache.maxSize; i++) {
+            cache.tryReserve(`fill-${i}`, 600);
+        }
+        await assert.rejects(() => pod.exchangeAuthorizationCode(registered, proxyCode, verifier, CLIENT_REDIRECT), /Authorization server busy/);
+    });
     test("exchangeAuthorizationCode rejects wrong client_id", async () => {
         const s = secret();
         const pod = makeProvider(loadMaterial(s));
@@ -316,6 +393,9 @@ describe("callback-proxy cross-pod flow (stateless)", () => {
         const proxyCode = new URL(cbRes.redirectedTo).searchParams.get("code");
         // Try to redeem as r2 (different client_id)
         await assert.rejects(() => pod.exchangeAuthorizationCode(r2, proxyCode, verifier, CLIENT_REDIRECT), /Invalid client for authorization code/);
+        // Failed binding must not burn the code for the legitimate client.
+        const tokens = await pod.exchangeAuthorizationCode(r1, proxyCode, verifier, CLIENT_REDIRECT);
+        assert.equal(tokens.access_token, "gl-access-123");
     });
     test("exchangeAuthorizationCode rejects wrong redirect_uri", async () => {
         const s = secret();
@@ -338,6 +418,9 @@ describe("callback-proxy cross-pod flow (stateless)", () => {
         await pod.handleCallback(fakeReq({ code: "g", state: proxyState }), cbRes);
         const proxyCode = new URL(cbRes.redirectedTo).searchParams.get("code");
         await assert.rejects(() => pod.exchangeAuthorizationCode(registered, proxyCode, verifier, "https://attacker.example/cb"), /Invalid redirect_uri for authorization code/);
+        // Failed binding must not burn the code for the legitimate client.
+        const tokens = await pod.exchangeAuthorizationCode(registered, proxyCode, verifier, CLIENT_REDIRECT);
+        assert.equal(tokens.access_token, "gl-access-123");
     });
     test("stale state rejected at /callback", async () => {
         const s = secret();
@@ -373,6 +456,32 @@ describe("callback-proxy cross-pod flow (stateless)", () => {
         const tokens = await pod.exchangeAuthorizationCode(registered, proxyCode, verifier, CLIENT_REDIRECT);
         assert.equal(tokens.access_token, "gl-access-123");
     });
+    test("legacy: failed PKCE does not burn the code; legitimate exchange still succeeds", async () => {
+        const pod = makeProvider(null);
+        const registered = await pod.clientsStore.registerClient({
+            redirect_uris: [CLIENT_REDIRECT],
+            token_endpoint_auth_method: "none",
+        });
+        const correctVerifier = randomBytes(32).toString("base64url");
+        const correctChallenge = createHash("sha256")
+            .update(correctVerifier)
+            .digest("base64url");
+        const aRes = makeAuthorizeRes();
+        await pod.authorize(registered, {
+            state: "s",
+            scopes: ["api"],
+            redirectUri: CLIENT_REDIRECT,
+            codeChallenge: correctChallenge,
+        }, aRes);
+        const legacyState = new URL(aRes.redirectedTo).searchParams.get("state");
+        const cbRes = makeFakeRes();
+        await pod.handleCallback(fakeReq({ code: "g", state: legacyState }), cbRes);
+        const proxyCode = new URL(cbRes.redirectedTo).searchParams.get("code");
+        const wrongVerifier = randomBytes(32).toString("base64url");
+        await assert.rejects(() => pod.exchangeAuthorizationCode(registered, proxyCode, wrongVerifier, CLIENT_REDIRECT), /PKCE verification failed/);
+        const tokens = await pod.exchangeAuthorizationCode(registered, proxyCode, correctVerifier, CLIENT_REDIRECT);
+        assert.equal(tokens.access_token, "gl-access-123");
+    });
     test("different secret on pod B rejects the sealed state", async () => {
         const podA = makeProvider(loadMaterial(secret()));
         const podB = makeProvider(loadMaterial(secret())); // different secret

package/build/test/stateless/consumed-proxy-code-cache.test.js

@@ -0,0 +1,150 @@
+/**
+ * Unit tests for ConsumedProxyCodeCache — TTL-aware replay prevention.
+ *
+ * Expectation (CWE-294): consumed hashes remain rejected until the configured
+ * code TTL expires; the cache never LRU-evicts early; inserts fail closed when
+ * still-valid entries fill capacity.
+ */
+import assert from "node:assert/strict";
+import { describe, test } from "node:test";
+import { ConsumedProxyCodeCache, PROXY_CODE_CACHE_FULL, } from "../../stateless/consumed-proxy-code-cache.js";
+function reserveId(cache, key, ttlSeconds) {
+    const result = cache.tryReserve(key, ttlSeconds);
+    assert.equal(result.ok, true);
+    if (!result.ok) {
+        throw new Error("expected reservation to succeed");
+    }
+    return result.reservationId;
+}
+describe("ConsumedProxyCodeCache", () => {
+    test("rejects replay of a committed hash for the full configured TTL", () => {
+        let now = 1_000_000;
+        const cache = new ConsumedProxyCodeCache(10, () => now);
+        const ttlSeconds = 120;
+        const id = reserveId(cache, "hash-a", ttlSeconds);
+        cache.commit("hash-a", id);
+        // Still within TTL — must reject as consumed.
+        now += (ttlSeconds - 1) * 1000;
+        assert.deepEqual(cache.tryReserve("hash-a", ttlSeconds), {
+            ok: false,
+            reason: "consumed",
+        });
+        // Exactly at expiry boundary — still rejected while expiresAt > now.
+        now += 999;
+        assert.deepEqual(cache.tryReserve("hash-a", ttlSeconds), {
+            ok: false,
+            reason: "consumed",
+        });
+        // After TTL — purged; a new reservation is allowed (sealed code itself
+        // would also be expired by openStoredTokensCode at this point).
+        now += 1;
+        assert.equal(cache.tryReserve("hash-a", ttlSeconds).ok, true);
+    });
+    test("never LRU-evicts a live entry; fails closed when full", () => {
+        const now = 5_000_000;
+        const maxSize = 3;
+        const cache = new ConsumedProxyCodeCache(maxSize, () => now);
+        const ttlSeconds = 600;
+        cache.commit("h1", reserveId(cache, "h1", ttlSeconds));
+        cache.commit("h2", reserveId(cache, "h2", ttlSeconds));
+        cache.commit("h3", reserveId(cache, "h3", ttlSeconds));
+        assert.equal(cache.size, 3);
+        // A fourth insert must fail closed — not silently drop h1.
+        assert.throws(() => cache.tryReserve("h4", ttlSeconds), (err) => {
+            return err.message === PROXY_CODE_CACHE_FULL;
+        });
+        // Original consumed hashes are still covered through the TTL window.
+        assert.deepEqual(cache.tryReserve("h1", ttlSeconds), {
+            ok: false,
+            reason: "consumed",
+        });
+        assert.deepEqual(cache.tryReserve("h2", ttlSeconds), {
+            ok: false,
+            reason: "consumed",
+        });
+        assert.deepEqual(cache.tryReserve("h3", ttlSeconds), {
+            ok: false,
+            reason: "consumed",
+        });
+        assert.equal(cache.size, 3);
+    });
+    test("purge of expired entries frees capacity without reopening live replays", () => {
+        let now = 9_000_000;
+        const cache = new ConsumedProxyCodeCache(2, () => now);
+        cache.commit("old", reserveId(cache, "old", 10));
+        cache.commit("live", reserveId(cache, "live", 600));
+        assert.equal(cache.size, 2);
+        // Expire only "old" so a new insert can reclaim that slot.
+        now += 10_000;
+        cache.commit("fresh", reserveId(cache, "fresh", 600));
+        assert.equal(cache.size, 2);
+        // Still-valid "live" hash must remain rejected through its TTL.
+        assert.deepEqual(cache.tryReserve("live", 600), {
+            ok: false,
+            reason: "consumed",
+        });
+        // Cache is full of non-expired entries — fail closed, do not LRU-evict.
+        assert.throws(() => cache.tryReserve("another", 600), (err) => {
+            return err.message === PROXY_CODE_CACHE_FULL;
+        });
+    });
+    test("release drops pending reservation but not committed entries", () => {
+        const now = 2_000_000;
+        const cache = new ConsumedProxyCodeCache(10, () => now);
+        const pendingId = reserveId(cache, "pending", 60);
+        cache.release("pending", pendingId);
+        assert.equal(cache.size, 0);
+        const retryId = reserveId(cache, "pending", 60);
+        cache.commit("pending", retryId);
+        cache.release("pending", retryId);
+        assert.equal(cache.size, 1);
+        assert.deepEqual(cache.tryReserve("pending", 60), {
+            ok: false,
+            reason: "consumed",
+        });
+    });
+    test("pending reservation also blocks concurrent replay attempts", () => {
+        const cache = new ConsumedProxyCodeCache(10, () => 3_000_000);
+        assert.equal(cache.tryReserve("in-flight", 120).ok, true);
+        assert.deepEqual(cache.tryReserve("in-flight", 120), {
+            ok: false,
+            reason: "pending",
+        });
+    });
+    test("non-finite TTL still blocks a second reservation for the same key", () => {
+        const cache = new ConsumedProxyCodeCache(10, () => 4_000_000);
+        assert.equal(cache.tryReserve("nan-ttl", Number.NaN).ok, true);
+        assert.deepEqual(cache.tryReserve("nan-ttl", Number.NaN), {
+            ok: false,
+            reason: "pending",
+        });
+    });
+    test("extreme finite TTL keeps expiresAt finite and evictable", () => {
+        let now = 1_000_000;
+        const cache = new ConsumedProxyCodeCache(10, () => now);
+        cache.commit("max-ttl", reserveId(cache, "max-ttl", Number.MAX_VALUE));
+        assert.deepEqual(cache.tryReserve("max-ttl", Number.MAX_VALUE), {
+            ok: false,
+            reason: "consumed",
+        });
+        // Advance past the capped expiry so purgeExpired can reclaim the slot.
+        now += Math.floor(Number.MAX_SAFE_INTEGER / 1000) * 1000 + 1;
+        assert.equal(cache.tryReserve("max-ttl", 60).ok, true);
+    });
+    test("stale reservation id cannot release or commit a newer reservation", () => {
+        let now = 1_000_000;
+        const cache = new ConsumedProxyCodeCache(10, () => now);
+        const ttlSeconds = 10;
+        const staleId = reserveId(cache, "key", ttlSeconds);
+        now += 11_000;
+        const liveId = reserveId(cache, "key", ttlSeconds);
+        cache.release("key", staleId);
+        assert.deepEqual(cache.tryReserve("key", ttlSeconds), {
+            ok: false,
+            reason: "pending",
+        });
+        cache.commit("key", staleId);
+        cache.release("key", liveId);
+        assert.equal(cache.tryReserve("key", ttlSeconds).ok, true);
+    });
+});

package/build/test/streamable-http-sse-stream.test.js

@@ -0,0 +1,350 @@
+import { after, before, describe, it } from "node:test";
+import assert from "node:assert";
+import { cleanupServers, findAvailablePort, HOST, launchServer, TransportMode, } from "./utils/server-launcher.js";
+import { findMockServerPort, MockGitLabServer } from "./utils/mock-gitlab-server.js";
+const VALID_TOKEN = "test-token-sse-stream-12345";
+async function postJsonRpc(url, body, headers = {}) {
+    const response = await fetch(url, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            Accept: "application/json, text/event-stream",
+            ...headers,
+        },
+        body: JSON.stringify(body),
+    });
+    const sessionId = response.headers.get("mcp-session-id");
+    const text = await response.text();
+    const contentType = response.headers.get("content-type") ?? "";
+    if (contentType.includes("text/event-stream")) {
+        const dataLines = text
+            .split("\n")
+            .filter(line => line.startsWith("data: "))
+            .map(line => line.slice(6));
+        const lastLine = dataLines.at(-1);
+        const parsedData = lastLine && lastLine.length > 0 ? JSON.parse(lastLine) : null;
+        return {
+            status: response.status,
+            data: parsedData,
+            sessionId,
+            text,
+        };
+    }
+    const parsedData = text.length > 0 ? JSON.parse(text) : null;
+    return {
+        status: response.status,
+        data: parsedData,
+        sessionId,
+        text,
+    };
+}
+describe("When Streamable HTTP server is running", () => {
+    let mockGitLab = null;
+    let server = null;
+    let mcpUrl = "";
+    before(async () => {
+        const mockPort = await findMockServerPort();
+        mockGitLab = new MockGitLabServer({
+            port: mockPort,
+            validTokens: [VALID_TOKEN],
+        });
+        await mockGitLab.start();
+        const port = await findAvailablePort(3720);
+        server = await launchServer({
+            mode: TransportMode.STREAMABLE_HTTP,
+            port,
+            timeout: 10_000,
+            env: {
+                STREAMABLE_HTTP: "true",
+                REMOTE_AUTHORIZATION: "true",
+                GITLAB_ALLOW_UNAUTHENTICATED_TOOL_DISCOVERY: "true",
+                GITLAB_API_URL: `${mockGitLab.getUrl()}/api/v4`,
+                GITLAB_TOOLSETS: "merge_requests",
+            },
+        });
+        mcpUrl = `http://${HOST}:${port}/mcp`;
+    });
+    after(async () => {
+        if (server) {
+            await cleanupServers([server]);
+            server = null;
+        }
+        if (mockGitLab) {
+            await mockGitLab.stop();
+            mockGitLab = null;
+        }
+    });
+    describe("with initialize handshake", () => {
+        it("should advertise tools.listChanged capability in server capabilities", async () => {
+            // Given: initialize request body
+            const initBody = {
+                jsonrpc: "2.0",
+                id: 1,
+                method: "initialize",
+                params: {
+                    protocolVersion: "2025-03-26",
+                    capabilities: {},
+                    clientInfo: { name: "test-client", version: "1.0.0" },
+                },
+            };
+            // When: client sends initialize request to /mcp
+            const response = await postJsonRpc(mcpUrl, initBody);
+            // Then: response should be 200 and include tools.listChanged: true
+            assert.strictEqual(response.status, 200, response.text);
+            assert.ok(response.sessionId, "initialize should return Mcp-Session-Id");
+            const result = response.data?.result;
+            assert.ok(typeof result === "object" && result !== null, "Result should be an object");
+            assert.ok(result.capabilities?.tools, "capabilities.tools should be defined");
+            assert.strictEqual(result.capabilities.tools.listChanged, true, "tools.listChanged capability must be true");
+        });
+    });
+    describe("with GET requests on /mcp", () => {
+        it("should return 406 when Accept header lacks text/event-stream", async () => {
+            // Given: GET request without Accept: text/event-stream
+            const response = await fetch(mcpUrl, {
+                method: "GET",
+                headers: {
+                    Accept: "application/json",
+                },
+            });
+            // When: server evaluates the request
+            const body = await response.json();
+            // Then: server should respond with 406 Not Acceptable
+            assert.strictEqual(response.status, 406);
+            assert.strictEqual(body?.error, "Not Acceptable");
+            const allowHeader = response.headers.get("allow");
+            assert.ok(allowHeader?.includes("GET"), "Allow header should contain GET");
+            assert.ok(allowHeader?.includes("POST"), "Allow header should contain POST");
+            assert.ok(allowHeader?.includes("DELETE"), "Allow header should contain DELETE");
+        });
+        it("should return 400 when Mcp-Session-Id header is missing", async () => {
+            // Given: GET request with Accept: text/event-stream but without Mcp-Session-Id
+            const response = await fetch(mcpUrl, {
+                method: "GET",
+                headers: {
+                    Accept: "text/event-stream",
+                },
+            });
+            // When: server evaluates the request
+            const body = await response.json();
+            // Then: server should respond with 400 Bad Request
+            assert.strictEqual(response.status, 400);
+            assert.strictEqual(body?.error, "Bad Request");
+        });
+        it("should return 404 when Mcp-Session-Id does not match any active session", async () => {
+            // Given: GET request with unknown session ID
+            const response = await fetch(mcpUrl, {
+                method: "GET",
+                headers: {
+                    Accept: "text/event-stream",
+                    "Mcp-Session-Id": "non-existent-session-id-12345",
+                },
+            });
+            // When: server evaluates the request
+            const body = await response.json();
+            // Then: server should respond with 404 Session not found
+            assert.strictEqual(response.status, 404);
+            assert.strictEqual(body?.error, "Session not found");
+        });
+        it("should establish SSE stream when valid Mcp-Session-Id and Accept header are provided", async () => {
+            // Given: an initialized session
+            const initBody = {
+                jsonrpc: "2.0",
+                id: 10,
+                method: "initialize",
+                params: {
+                    protocolVersion: "2025-03-26",
+                    capabilities: {},
+                    clientInfo: { name: "sse-stream-client", version: "1.0.0" },
+                },
+            };
+            const initResponse = await postJsonRpc(mcpUrl, initBody);
+            const sessionId = initResponse.sessionId;
+            assert.ok(sessionId, "Session ID should be present");
+            // When: client connects with GET /mcp and Accept: text/event-stream
+            const abortController = new AbortController();
+            const sseResponse = await fetch(mcpUrl, {
+                method: "GET",
+                headers: {
+                    Accept: "text/event-stream",
+                    "Mcp-Session-Id": sessionId,
+                },
+                signal: abortController.signal,
+            });
+            // Then: response should be 200 with Content-Type text/event-stream
+            assert.strictEqual(sseResponse.status, 200);
+            const contentType = sseResponse.headers.get("content-type") ?? "";
+            assert.ok(contentType.includes("text/event-stream"), "Content-Type must be text/event-stream");
+            abortController.abort();
+        });
+        it("should receive list_changed notification over SSE stream when discover_tools runs", async () => {
+            // Given: an authenticated session connected to GET /mcp SSE stream
+            const initBody = {
+                jsonrpc: "2.0",
+                id: 20,
+                method: "initialize",
+                params: {
+                    protocolVersion: "2025-03-26",
+                    capabilities: {},
+                    clientInfo: { name: "sse-notify-client", version: "1.0.0" },
+                },
+            };
+            const initResponse = await postJsonRpc(mcpUrl, initBody, {
+                "Private-Token": VALID_TOKEN,
+            });
+            const sessionId = initResponse.sessionId;
+            assert.ok(sessionId, "Session ID should be present");
+            // Initialized notification
+            await postJsonRpc(mcpUrl, {
+                jsonrpc: "2.0",
+                method: "notifications/initialized",
+            }, {
+                "mcp-session-id": sessionId,
+                "Private-Token": VALID_TOKEN,
+            });
+            const abortController = new AbortController();
+            const sseResponse = await fetch(mcpUrl, {
+                method: "GET",
+                headers: {
+                    Accept: "text/event-stream",
+                    "Mcp-Session-Id": sessionId,
+                    "Private-Token": VALID_TOKEN,
+                },
+                signal: abortController.signal,
+            });
+            assert.strictEqual(sseResponse.status, 200);
+            const streamReader = sseResponse.body?.getReader();
+            assert.ok(streamReader, "SSE response body reader should exist");
+            const decoder = new TextDecoder();
+            let receivedEvents = "";
+            // Background listener to collect SSE chunks
+            const readPromise = (async () => {
+                try {
+                    while (true) {
+                        const { done, value } = await streamReader.read();
+                        if (done)
+                            break;
+                        receivedEvents += decoder.decode(value, { stream: true });
+                        if (receivedEvents.includes("notifications/tools/list_changed")) {
+                            break;
+                        }
+                    }
+                }
+                catch {
+                    // Stream closed or aborted
+                }
+            })();
+            // When: client calls discover_tools to activate pipelines category
+            const discoverResponse = await postJsonRpc(mcpUrl, {
+                jsonrpc: "2.0",
+                id: 21,
+                method: "tools/call",
+                params: {
+                    name: "discover_tools",
+                    arguments: {
+                        category: "pipelines",
+                    },
+                },
+            }, {
+                "mcp-session-id": sessionId,
+                "Private-Token": VALID_TOKEN,
+            });
+            // Then: discover_tools succeeds and list_changed notification arrives on SSE stream
+            assert.strictEqual(discoverResponse.status, 200, discoverResponse.text);
+            let timeoutHandle;
+            try {
+                await Promise.race([
+                    readPromise,
+                    new Promise(resolve => {
+                        timeoutHandle = setTimeout(resolve, 3000);
+                    }),
+                ]);
+            }
+            finally {
+                if (timeoutHandle)
+                    clearTimeout(timeoutHandle);
+            }
+            abortController.abort();
+            assert.ok(receivedEvents.includes("notifications/tools/list_changed"), `SSE stream should receive notifications/tools/list_changed. Received: ${receivedEvents}`);
+        });
+    });
+    describe("with unsupported HTTP methods", () => {
+        it("should return 405 Method Not Allowed for PUT requests", async () => {
+            // Given: PUT request to /mcp
+            const response = await fetch(mcpUrl, { method: "PUT" });
+            // When: server evaluates the method
+            const body = await response.json();
+            // Then: server should respond with 405 Method Not Allowed
+            assert.strictEqual(response.status, 405);
+            assert.strictEqual(body?.error, "Method Not Allowed");
+            const allowHeader = response.headers.get("allow");
+            assert.ok(allowHeader?.includes("GET"), "Allow header must contain GET");
+            assert.ok(allowHeader?.includes("POST"), "Allow header must contain POST");
+            assert.ok(allowHeader?.includes("DELETE"), "Allow header must contain DELETE");
+        });
+    });
+});
+describe("When Streamable HTTP GET SSE is open", { timeout: 20_000 }, () => {
+    describe("with a short session timeout and no POST traffic", () => {
+        it("should keep the session alive for the life of the SSE stream", async () => {
+            const mockPort = await findMockServerPort();
+            const mockGitLab = new MockGitLabServer({
+                port: mockPort,
+                validTokens: [VALID_TOKEN],
+            });
+            await mockGitLab.start();
+            const port = await findAvailablePort(3740);
+            const timeoutServer = await launchServer({
+                mode: TransportMode.STREAMABLE_HTTP,
+                port,
+                timeout: 10_000,
+                env: {
+                    STREAMABLE_HTTP: "true",
+                    REMOTE_AUTHORIZATION: "true",
+                    GITLAB_API_URL: `${mockGitLab.getUrl()}/api/v4`,
+                    SESSION_TIMEOUT_SECONDS: "1",
+                },
+            });
+            const timeoutMcpUrl = `http://${HOST}:${port}/mcp`;
+            try {
+                // Given: an authenticated session with an open GET SSE stream
+                const initResponse = await postJsonRpc(timeoutMcpUrl, {
+                    jsonrpc: "2.0",
+                    id: 1,
+                    method: "initialize",
+                    params: {
+                        protocolVersion: "2025-03-26",
+                        capabilities: {},
+                        clientInfo: { name: "sse-keepalive-client", version: "1.0.0" },
+                    },
+                }, { "Private-Token": VALID_TOKEN });
+                const sessionId = initResponse.sessionId;
+                assert.ok(sessionId, "Session ID should be present");
+                const abortController = new AbortController();
+                const sseResponse = await fetch(timeoutMcpUrl, {
+                    method: "GET",
+                    headers: {
+                        Accept: "text/event-stream",
+                        "Mcp-Session-Id": sessionId,
+                        "Private-Token": VALID_TOKEN,
+                    },
+                    signal: abortController.signal,
+                });
+                assert.strictEqual(sseResponse.status, 200);
+                // When: more than SESSION_TIMEOUT_SECONDS elapses with no POST
+                await new Promise(resolve => setTimeout(resolve, 2_000));
+                const listResponse = await postJsonRpc(timeoutMcpUrl, { jsonrpc: "2.0", id: 2, method: "tools/list", params: {} }, {
+                    "mcp-session-id": sessionId,
+                    "Private-Token": VALID_TOKEN,
+                });
+                // Then: the session is still alive
+                assert.strictEqual(listResponse.status, 200, listResponse.text);
+                abortController.abort();
+            }
+            finally {
+                await cleanupServers([timeoutServer]);
+                await mockGitLab.stop();
+            }
+        });
+    });
+});