@zereight/mcp-gitlab 2.1.25 → 2.1.27

package/build/test/dynamic-api-url-allowlist.test.js

@@ -0,0 +1,104 @@
+import { after, before, describe, test } from "node:test";
+import assert from "node:assert";
+import { createServer } from "node:http";
+import { cleanupServers, findAvailablePort, HOST, launchServer, TransportMode, } from "./utils/server-launcher.js";
+import { MockGitLabServer, findMockServerPort } from "./utils/mock-gitlab-server.js";
+import { CustomHeaderClient } from "./clients/custom-header-client.js";
+const MOCK_TOKEN = "glpat-dynamic-url-token";
+async function startAttackerServer(port) {
+    let hits = 0;
+    const server = createServer((_req, res) => {
+        hits++;
+        res.writeHead(200, { "content-type": "application/json" });
+        res.end("[]");
+    });
+    await new Promise((resolve, reject) => {
+        server.once("error", reject);
+        server.listen(port, HOST, () => {
+            server.off("error", reject);
+            resolve();
+        });
+    });
+    return { server, getHits: () => hits };
+}
+describe("Dynamic API URL allowlist", () => {
+    let primaryGitLab;
+    let secondaryGitLab;
+    let attackerServer;
+    let mcpServer;
+    let mcpUrl;
+    let secondaryHit = false;
+    let getAttackerHits = () => 0;
+    before(async () => {
+        const primaryPort = await findMockServerPort(9100);
+        primaryGitLab = new MockGitLabServer({ port: primaryPort, validTokens: [MOCK_TOKEN] });
+        await primaryGitLab.start();
+        const secondaryPort = await findMockServerPort(9200);
+        secondaryGitLab = new MockGitLabServer({ port: secondaryPort, validTokens: [MOCK_TOKEN] });
+        secondaryGitLab.addMockHandler("get", "/projects/1/issues", (_req, res) => {
+            secondaryHit = true;
+            res.json([]);
+        });
+        await secondaryGitLab.start();
+        const attackerPort = await findAvailablePort(9300);
+        const attacker = await startAttackerServer(attackerPort);
+        attackerServer = attacker.server;
+        getAttackerHits = attacker.getHits;
+        const mcpPort = await findAvailablePort(3100);
+        mcpServer = await launchServer({
+            mode: TransportMode.STREAMABLE_HTTP,
+            port: mcpPort,
+            timeout: 5000,
+            env: {
+                STREAMABLE_HTTP: "true",
+                REMOTE_AUTHORIZATION: "true",
+                ENABLE_DYNAMIC_API_URL: "true",
+                GITLAB_API_URL: `${primaryGitLab.getUrl()}/api/v4`,
+                GITLAB_ALLOWED_HOSTS: `${secondaryGitLab.getUrl()}/api/v4`,
+            },
+        });
+        mcpUrl = `http://${HOST}:${mcpPort}/mcp`;
+    });
+    after(async () => {
+        if (mcpServer)
+            cleanupServers([mcpServer]);
+        await primaryGitLab?.stop();
+        await secondaryGitLab?.stop();
+        const server = attackerServer;
+        if (server)
+            await new Promise(resolve => server.close(() => resolve()));
+    });
+    test("allows dynamic API URLs on configured hosts", async () => {
+        const client = new CustomHeaderClient({
+            authorization: `Bearer ${MOCK_TOKEN}`,
+            "x-gitlab-api-url": `${secondaryGitLab.getUrl()}/api/v4`,
+        });
+        await client.connect(mcpUrl);
+        await client.callTool("list_issues", { project_id: "1" });
+        await client.disconnect();
+        assert.strictEqual(secondaryHit, true, "allowed dynamic host should receive GitLab calls");
+    });
+    test("rejects dynamic API URLs on unconfigured hosts before forwarding tokens", async () => {
+        const server = attackerServer;
+        assert.ok(server, "attacker server should be running");
+        const attackerUrl = `http://${HOST}:${server.address().port}/api/v4`;
+        const client = new CustomHeaderClient({
+            authorization: `Bearer ${MOCK_TOKEN}`,
+            "x-gitlab-api-url": attackerUrl,
+        });
+        let connected = false;
+        try {
+            await client.connect(mcpUrl);
+            connected = true;
+            await client.callTool("list_issues", { project_id: "1" });
+        }
+        catch {
+            // Expected: the session is rejected before any GitLab API request is made.
+        }
+        finally {
+            await client.disconnect();
+        }
+        assert.strictEqual(connected, false, "untrusted dynamic host should not initialize a session");
+        assert.strictEqual(getAttackerHits(), 0, "token-bearing requests must not reach untrusted hosts");
+    });
+});

package/build/test/dynamic-api-url-test.js

@@ -233,7 +233,7 @@ describe('Dynamic API URL - Connection Pool', () => {
         });
         servers.push(server);
         mcpUrl = `http://${HOST}:${mcpPort}/mcp`;
-        metricsUrl = `http://${HOST}:${mcpPort}/metrics`;
+        metricsUrl = `http://${HOST}:${mcpPort}/metrics.json`;
         console.log(`MCP Server: ${mcpUrl}`);
         console.log(`Metrics URL: ${metricsUrl}`);
     });
@@ -246,7 +246,7 @@ describe('Dynamic API URL - Connection Pool', () => {
             await mockGitLab2.stop();
         }
     });
-    test('should track pool statistics via metrics endpoint', async () => {
+    test('should track pool statistics via metrics JSON endpoint', async () => {
         // Make some connections first
         const client1 = new CustomHeaderClient({
             'authorization': `Bearer ${MOCK_TOKEN_1}`,
@@ -262,7 +262,7 @@ describe('Dynamic API URL - Connection Pool', () => {
         await client2.listTools();
         // Check metrics
         const response = await fetch(metricsUrl);
-        assert.ok(response.ok, 'Metrics endpoint should be accessible');
+        assert.ok(response.ok, 'Metrics JSON endpoint should be accessible');
         const metrics = await response.json();
         assert.ok(metrics.gitlabClientPool, 'Should have pool metrics');
         assert.ok(typeof metrics.gitlabClientPool.size === 'number', 'Should have pool size');

package/build/test/oauth-tests.js

@@ -214,6 +214,44 @@ async function testPortAvailability() {
     // We just check that the function works, not the actual availability
     assert(typeof available === 'boolean', 'Port availability check should return boolean');
 }
+// Test: External OAuth token script
+async function testOAuthTokenScript() {
+    const scriptPath = path.join(process.cwd(), '.test-oauth-token-script.sh');
+    const writeScript = (output) => {
+        fs.writeFileSync(scriptPath, `#!/bin/sh\nprintf '%s\\n' '${output}'\n`, { mode: 0o700 });
+    };
+    const oauth = () => new GitLabOAuth({
+        clientId: TEST_CLIENT_ID,
+        redirectUri: TEST_REDIRECT_URI,
+        gitlabUrl: TEST_GITLAB_URL,
+        scopes: ['api'],
+        tokenStoragePath: TEST_TOKEN_PATH,
+        tokenScript: scriptPath,
+    });
+    try {
+        writeScript('script-token-123');
+        const plainToken = await oauth().getAccessToken();
+        assert(plainToken === 'script-token-123', 'Should return plain token from external script');
+        assert(oauth().hasValidToken(), 'Token script should count as a valid token source');
+        writeScript(JSON.stringify({ access_token: 'json-token-123' }));
+        const jsonToken = await oauth().getAccessToken();
+        assert(jsonToken === 'json-token-123', 'Should extract access_token from JSON output');
+        writeScript(JSON.stringify({ expires_in: 3600 }));
+        try {
+            await oauth().getAccessToken();
+            assert(false, 'Should reject JSON output without a token field');
+        }
+        catch (error) {
+            assert(error instanceof Error &&
+                error.message.includes('OAuth token script JSON must include a string access_token or token field'), 'Should explain missing token field in JSON output');
+        }
+    }
+    finally {
+        if (fs.existsSync(scriptPath)) {
+            fs.unlinkSync(scriptPath);
+        }
+    }
+}
 // Test 11: OAuth redirect URI parsing
 async function testRedirectUriParsing() {
     const redirectUri = 'http://127.0.0.1:8888/callback';
@@ -332,6 +370,7 @@ async function runOAuthTests() {
     await runTest('hasValidToken returns false with expired token', testHasValidTokenExpired);
     await runTest('clearToken removes token file', testClearToken);
     await runTest('Token file has correct permissions', testTokenFilePermissions, process.platform === 'win32');
+    await runTest('External OAuth token script', testOAuthTokenScript, process.platform === 'win32');
     // Network and configuration tests
     await runTest('Port availability check', testPortAvailability);
     await runTest('OAuth redirect URI parsing', testRedirectUriParsing);

package/build/test/remote-auth-simple-test.js

@@ -22,9 +22,9 @@ const TIMEOUT_TEST_WAIT_MS = SESSION_TIMEOUT_SECONDS * 1000 + TIMEOUT_BUFFER_MS;
 const KEEPALIVE_INTERVAL_MS = 2000; // Must be less than SESSION_TIMEOUT_SECONDS
 const KEEPALIVE_REQUEST_COUNT = 3; // Number of keepalive requests to test
 async function getMetrics(mcpUrl) {
-    const metricsUrl = mcpUrl.replace(/\/mcp$/, '/metrics');
+    const metricsUrl = mcpUrl.replace(/\/mcp$/, '/metrics.json');
     const response = await fetch(metricsUrl);
-    assert.strictEqual(response.status, 200, 'metrics endpoint should be available');
+    assert.strictEqual(response.status, 200, 'metrics JSON endpoint should be available');
     return (await response.json());
 }
 async function waitForSessionDecrease(mcpUrl, beforeTimeout, timeoutMs = 3000) {
@@ -125,6 +125,17 @@ describe('Remote Authorization - Basic Functionality', () => {
         console.log('  ✓ Multiple tool list calls successful with persistent auth');
         await client.disconnect();
     });
+    test('should expose Prometheus metrics at /metrics', async () => {
+        const metricsUrl = mcpUrl.replace(/\/mcp$/, '/metrics');
+        const response = await fetch(metricsUrl);
+        assert.strictEqual(response.status, 200, 'metrics endpoint should be available');
+        assert.match(response.headers.get('content-type') || '', /^text\/plain/);
+        const body = await response.text();
+        assert.match(body, /# HELP gitlab_mcp_requests_processed_total/);
+        assert.match(body, /# TYPE gitlab_mcp_active_sessions gauge/);
+        assert.match(body, /gitlab_mcp_config_info\{[^}]*remote_auth_enabled="true"/);
+        console.log('  ✓ Prometheus metrics available');
+    });
     test('should reject connection without auth header', async () => {
         const client = new CustomHeaderClient({});
         try {

package/build/test/schema-tests.js

@@ -771,6 +771,57 @@ function runGitLabMergeRequestSchemaTests() {
             },
             validate: (data) => data.labels === undefined,
         },
+        {
+            name: 'schema:gitlab_merge_request:preserves-merge-user',
+            input: {
+                ...baseMergeRequest,
+                state: 'merged',
+                merged_at: '2026-05-08T00:00:00.000Z',
+                merge_commit_sha: 'abc123',
+                merge_user: {
+                    id: '7',
+                    username: 'merger',
+                    name: 'Merge Bot',
+                    avatar_url: null,
+                    web_url: 'https://gitlab.example.com/merger',
+                },
+            },
+            validate: (data) => data.merge_user?.id === '7' &&
+                data.merge_user?.username === 'merger' &&
+                data.merge_user?.name === 'Merge Bot',
+        },
+        {
+            name: 'schema:gitlab_merge_request:preserves-merged-by',
+            input: {
+                ...baseMergeRequest,
+                state: 'merged',
+                merged_by: {
+                    id: '8',
+                    username: 'legacy-merger',
+                    name: 'Legacy Merger',
+                    avatar_url: null,
+                    web_url: 'https://gitlab.example.com/legacy-merger',
+                },
+            },
+            validate: (data) => data.merged_by?.id === '8' &&
+                data.merged_by?.username === 'legacy-merger',
+        },
+        {
+            name: 'schema:gitlab_merge_request:allows-null-merge-user',
+            input: {
+                ...baseMergeRequest,
+                merge_user: null,
+                merged_by: null,
+            },
+            validate: (data) => data.merge_user === null && data.merged_by === null,
+        },
+        {
+            name: 'schema:gitlab_merge_request:allows-omitted-merge-user',
+            input: {
+                ...baseMergeRequest,
+            },
+            validate: (data) => data.merge_user === undefined && data.merged_by === undefined,
+        },
     ];
     let passed = 0;
     let failed = 0;

package/build/test/sse-auth-guard.test.js

@@ -0,0 +1,96 @@
+import assert from "node:assert/strict";
+import { spawn } from "node:child_process";
+import { once } from "node:events";
+import { afterEach, describe, test } from "node:test";
+import * as path from "node:path";
+import { findAvailablePort } from "./utils/server-launcher.js";
+const ERROR_MESSAGE = "SSE=true on a non-loopback HOST requires SSE_AUTH_TOKEN (or explicitly set SSE_DANGEROUSLY_ALLOW_UNAUTHENTICATED_REMOTE=true)";
+const LOOPBACK = "127.0.0.1";
+const SERVER_PATH = path.resolve(process.cwd(), "build/index.js");
+const running = new Set();
+function startSseServer(env, port) {
+    const child = spawn("node", [SERVER_PATH], {
+        env: {
+            ...process.env,
+            GITLAB_API_URL: "https://gitlab.example.com/api/v4",
+            HOST: "0.0.0.0",
+            PORT: String(port),
+            SSE: "true",
+            STREAMABLE_HTTP: "false",
+            REMOTE_AUTHORIZATION: "false",
+            GITLAB_MCP_OAUTH: "false",
+            GITLAB_USE_OAUTH: "false",
+            GITLAB_PERSONAL_ACCESS_TOKEN: "glpat_test",
+            GITLAB_JOB_TOKEN: "",
+            GITLAB_AUTH_COOKIE_PATH: "",
+            ...env,
+        },
+        stdio: ["ignore", "pipe", "pipe"],
+    });
+    running.add(child);
+    child.once("exit", () => running.delete(child));
+    return child;
+}
+async function waitForExit(child, timeoutMs = 5000) {
+    let output = "";
+    child.stdout?.on("data", chunk => {
+        output += chunk.toString();
+    });
+    child.stderr?.on("data", chunk => {
+        output += chunk.toString();
+    });
+    let timeoutHandle;
+    const timeout = new Promise((_, reject) => {
+        timeoutHandle = setTimeout(() => reject(new Error(`server did not exit within ${timeoutMs}ms`)), timeoutMs);
+    });
+    try {
+        const [code] = (await Promise.race([once(child, "exit"), timeout]));
+        return { code, output };
+    }
+    finally {
+        clearTimeout(timeoutHandle);
+    }
+}
+async function waitForHealth(port, timeoutMs = 5000) {
+    const deadline = Date.now() + timeoutMs;
+    let lastError;
+    while (Date.now() < deadline) {
+        try {
+            const response = await fetch(`http://${LOOPBACK}:${port}/health`);
+            if (response.ok)
+                return;
+        }
+        catch (error) {
+            lastError = error;
+        }
+        await new Promise(resolve => setTimeout(resolve, 100));
+    }
+    throw new Error(`server did not become healthy: ${String(lastError)}`);
+}
+afterEach(() => {
+    for (const child of running) {
+        if (!child.killed)
+            child.kill("SIGTERM");
+    }
+    running.clear();
+});
+describe("SSE remote auth guard", () => {
+    test("refuses unauthenticated SSE on non-loopback hosts", async () => {
+        const port = await findAvailablePort(4400);
+        const child = startSseServer({}, port);
+        const { code, output } = await waitForExit(child);
+        assert.notEqual(code, 0);
+        assert.match(output, new RegExp(ERROR_MESSAGE.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")));
+    });
+    test("requires bearer auth on SSE endpoints when SSE_AUTH_TOKEN is configured", async () => {
+        const port = await findAvailablePort(4410);
+        startSseServer({ SSE_AUTH_TOKEN: "mcp_sse_secret" }, port);
+        await waitForHealth(port);
+        const sseResponse = await fetch(`http://${LOOPBACK}:${port}/sse`);
+        assert.equal(sseResponse.status, 401);
+        const unauthenticatedMessage = await fetch(`http://${LOOPBACK}:${port}/messages?sessionId=missing`, { method: "POST" });
+        assert.equal(unauthenticatedMessage.status, 401);
+        const authenticatedMessage = await fetch(`http://${LOOPBACK}:${port}/messages?sessionId=missing`, { method: "POST", headers: { Authorization: "Bearer mcp_sse_secret" } });
+        assert.equal(authenticatedMessage.status, 400);
+    });
+});

package/build/test/streamable-http-concurrent-session.test.js

@@ -0,0 +1,92 @@
+import { after, before, describe, test } from "node:test";
+import assert from "node:assert";
+import { Buffer } from "node:buffer";
+import { cleanupServers, findAvailablePort, HOST, launchServer, TransportMode, } from "./utils/server-launcher.js";
+import { findMockServerPort, MockGitLabServer } from "./utils/mock-gitlab-server.js";
+import { CustomHeaderClient } from "./clients/custom-header-client.js";
+const MOCK_TOKEN = "mock-concurrent-token-12345";
+const TEST_PROJECT_ID = "123";
+function fileResponse(filePath, content) {
+    return {
+        file_name: filePath.split("/").at(-1),
+        file_path: filePath,
+        encoding: "base64",
+        content: Buffer.from(content, "utf8").toString("base64"),
+    };
+}
+describe("Streamable HTTP concurrent session requests", { timeout: 20_000 }, () => {
+    let mockGitLab;
+    let server;
+    let mcpUrl;
+    before(async () => {
+        const mockPort = await findMockServerPort(9360);
+        mockGitLab = new MockGitLabServer({
+            port: mockPort,
+            validTokens: [MOCK_TOKEN],
+            responseDelay: 100,
+        });
+        mockGitLab.addMockHandler("get", `/projects/${TEST_PROJECT_ID}/repository/files/package.json`, (_req, res) => {
+            res.json(fileResponse("package.json", "package file"));
+        });
+        mockGitLab.addMockHandler("get", `/projects/${TEST_PROJECT_ID}/repository/files/README.md`, (_req, res) => {
+            res.json(fileResponse("README.md", "readme file"));
+        });
+        await mockGitLab.start();
+        const port = await findAvailablePort(3460);
+        server = await launchServer({
+            mode: TransportMode.STREAMABLE_HTTP,
+            port,
+            timeout: 10_000,
+            env: {
+                STREAMABLE_HTTP: "true",
+                REMOTE_AUTHORIZATION: "true",
+                GITLAB_API_URL: `${mockGitLab.getUrl()}/api/v4`,
+            },
+        });
+        mcpUrl = `http://${HOST}:${port}/mcp`;
+    });
+    after(async () => {
+        cleanupServers([server]);
+        if (mockGitLab)
+            await mockGitLab.stop();
+    });
+    test("handles concurrent SDK tool calls with the same Mcp-Session-Id", async () => {
+        const client = new CustomHeaderClient({ Authorization: `Bearer ${MOCK_TOKEN}` });
+        await client.connect(mcpUrl);
+        try {
+            const initialSessionId = client.getSessionId();
+            assert.ok(initialSessionId, "initialize should return Mcp-Session-Id");
+            let timeoutHandle;
+            try {
+                const [packageResult, readmeResult] = await Promise.race([
+                    Promise.all([
+                        client.callTool("get_file_contents", {
+                            project_id: TEST_PROJECT_ID,
+                            file_path: "package.json",
+                            ref: "main",
+                        }),
+                        client.callTool("get_file_contents", {
+                            project_id: TEST_PROJECT_ID,
+                            file_path: "README.md",
+                            ref: "main",
+                        }),
+                    ]),
+                    new Promise((_, reject) => {
+                        timeoutHandle = setTimeout(() => reject(new Error("concurrent tool calls timed out")), 5_000);
+                    }),
+                ]);
+                const packageText = packageResult.content?.[0]?.type === "text" ? packageResult.content[0].text : "";
+                const readmeText = readmeResult.content?.[0]?.type === "text" ? readmeResult.content[0].text : "";
+                assert.strictEqual(client.getSessionId(), initialSessionId, "concurrent calls should reuse the same Mcp-Session-Id");
+                assert.ok(packageText.includes("package file"), packageText);
+                assert.ok(readmeText.includes("readme file"), readmeText);
+            }
+            finally {
+                clearTimeout(timeoutHandle);
+            }
+        }
+        finally {
+            await client.disconnect();
+        }
+    });
+});

package/build/test/streamable-http-unauthenticated-discovery.test.js

@@ -0,0 +1,113 @@
+import { after, describe, test } from "node:test";
+import assert from "node:assert";
+import { cleanupServers, findAvailablePort, HOST, launchServer, TransportMode, } from "./utils/server-launcher.js";
+async function rawMcpRequest(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");
+    if (response.status === 202 || response.status === 204) {
+        return { status: response.status, data: null, sessionId, text: "" };
+    }
+    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));
+        return {
+            status: response.status,
+            data: dataLines.length > 0 ? JSON.parse(dataLines.at(-1)) : null,
+            sessionId,
+            text,
+        };
+    }
+    return {
+        status: response.status,
+        data: text ? JSON.parse(text) : null,
+        sessionId,
+        text,
+    };
+}
+async function initialize(mcpUrl) {
+    const response = await rawMcpRequest(mcpUrl, {
+        jsonrpc: "2.0",
+        id: 1,
+        method: "initialize",
+        params: {
+            protocolVersion: "2025-03-26",
+            capabilities: {},
+            clientInfo: { name: "unauth-discovery-test", version: "1.0.0" },
+        },
+    });
+    assert.strictEqual(response.status, 200, response.text);
+    assert.ok(response.sessionId, "initialize should return Mcp-Session-Id");
+    return response.sessionId;
+}
+let portOffset = 0;
+async function launchRemoteAuthServer(extraEnv = {}) {
+    const port = await findAvailablePort(3470 + portOffset++ * 10);
+    const server = await launchServer({
+        mode: TransportMode.STREAMABLE_HTTP,
+        port,
+        timeout: 10_000,
+        env: {
+            STREAMABLE_HTTP: "true",
+            REMOTE_AUTHORIZATION: "true",
+            GITLAB_API_URL: "https://gitlab.example.com/api/v4",
+            ...extraEnv,
+        },
+    });
+    return { server, mcpUrl: `http://${HOST}:${port}/mcp` };
+}
+describe("Streamable HTTP unauthenticated tool discovery", { timeout: 20_000 }, () => {
+    let servers = [];
+    after(() => {
+        cleanupServers(servers);
+        servers = [];
+    });
+    test("keeps unauthenticated tools/list blocked by default", async () => {
+        const { server, mcpUrl } = await launchRemoteAuthServer();
+        servers.push(server);
+        const sessionId = await initialize(mcpUrl);
+        const listResponse = await rawMcpRequest(mcpUrl, { jsonrpc: "2.0", id: 2, method: "tools/list", params: {} }, { "mcp-session-id": sessionId });
+        assert.strictEqual(listResponse.status, 401, listResponse.text);
+    });
+    test("allows unauthenticated tools/list when explicitly enabled", async () => {
+        const { server, mcpUrl } = await launchRemoteAuthServer({
+            GITLAB_ALLOW_UNAUTHENTICATED_TOOL_DISCOVERY: "true",
+        });
+        servers.push(server);
+        const sessionId = await initialize(mcpUrl);
+        const initialized = await rawMcpRequest(mcpUrl, { jsonrpc: "2.0", method: "notifications/initialized" }, { "mcp-session-id": sessionId });
+        assert.ok([200, 202, 204].includes(initialized.status), initialized.text);
+        const listResponse = await rawMcpRequest(mcpUrl, { jsonrpc: "2.0", id: 2, method: "tools/list", params: {} }, { "mcp-session-id": sessionId });
+        assert.strictEqual(listResponse.status, 200, listResponse.text);
+        assert.ok(Array.isArray(listResponse.data.result?.tools), "tools/list should return tools");
+        assert.ok(listResponse.data.result.tools.length > 0, "tools/list should not be empty");
+    });
+    test("still blocks unauthenticated tools/call when discovery is enabled", async () => {
+        const { server, mcpUrl } = await launchRemoteAuthServer({
+            GITLAB_ALLOW_UNAUTHENTICATED_TOOL_DISCOVERY: "true",
+        });
+        servers.push(server);
+        const sessionId = await initialize(mcpUrl);
+        const callResponse = await rawMcpRequest(mcpUrl, {
+            jsonrpc: "2.0",
+            id: 3,
+            method: "tools/call",
+            params: {
+                name: "get_project",
+                arguments: { project_id: "123" },
+            },
+        }, { "mcp-session-id": sessionId });
+        assert.strictEqual(callResponse.status, 401, callResponse.text);
+    });
+});