@zereight/mcp-gitlab 2.1.29 → 2.1.38

package/build/test/streamable-http-dns-rebinding.test.js

@@ -0,0 +1,185 @@
+import assert from "node:assert/strict";
+import { spawn } from "node:child_process";
+import http from "node:http";
+import { afterEach, describe, test } from "node:test";
+import * as path from "node:path";
+import { findAvailablePort } from "./utils/server-launcher.js";
+import { MockGitLabServer, findMockServerPort } from "./utils/mock-gitlab-server.js";
+const HOST = process.env.HOST || "127.0.0.1";
+const SERVER_PATH = path.resolve(process.cwd(), "build/index.js");
+const TEST_TOKEN = "test-token-123456789012345";
+const running = new Set();
+const mockGitLabServers = [];
+function hostWithPort(host, port) {
+    const normalized = host.trim();
+    if (normalized.includes(":") && !normalized.startsWith("["))
+        return `[${normalized}]:${port}`;
+    return `${normalized}:${port}`;
+}
+function startServer(env, port) {
+    const child = spawn("node", [SERVER_PATH], {
+        env: {
+            ...process.env,
+            GITLAB_API_URL: "https://gitlab.example.com",
+            HOST,
+            PORT: String(port),
+            STREAMABLE_HTTP: "true",
+            REMOTE_AUTHORIZATION: "true",
+            GITLAB_MCP_OAUTH: "false",
+            GITLAB_USE_OAUTH: "false",
+            GITLAB_PERSONAL_ACCESS_TOKEN: "",
+            GITLAB_JOB_TOKEN: "",
+            GITLAB_AUTH_COOKIE_PATH: "",
+            MCP_SERVER_URL: "",
+            GITLAB_OAUTH_APP_ID: "",
+            ...env,
+        },
+        stdio: ["ignore", "pipe", "pipe"],
+    });
+    running.add(child);
+    child.once("exit", () => running.delete(child));
+    return child;
+}
+async function startAuthenticatedServer(env, port) {
+    const mockPort = await findMockServerPort();
+    const mockGitLab = new MockGitLabServer({
+        port: mockPort,
+        validTokens: [TEST_TOKEN],
+    });
+    await mockGitLab.start();
+    mockGitLabServers.push(mockGitLab);
+    startServer({
+        GITLAB_API_URL: `${mockGitLab.getUrl()}/api/v4`,
+        ...env,
+    }, port);
+}
+async function waitForHealth(port, timeoutMs = 5000) {
+    const deadline = Date.now() + timeoutMs;
+    let lastError;
+    while (Date.now() < deadline) {
+        try {
+            const response = await fetch(`http://${hostWithPort(HOST, 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)}`);
+}
+function postMcp(port, headers, body = JSON.stringify({
+    jsonrpc: "2.0",
+    id: 1,
+    method: "initialize",
+    params: {
+        protocolVersion: "2025-03-26",
+        capabilities: {},
+        clientInfo: { name: "dns-rebinding-test", version: "1.0.0" },
+    },
+})) {
+    return new Promise((resolve, reject) => {
+        const req = http.request({
+            host: HOST,
+            port,
+            path: "/mcp",
+            method: "POST",
+            headers: {
+                Host: hostWithPort(HOST, port),
+                "Content-Type": "application/json",
+                Accept: "application/json, text/event-stream",
+                "Private-Token": TEST_TOKEN,
+                "Content-Length": Buffer.byteLength(body).toString(),
+                ...headers,
+            },
+        }, res => {
+            let responseBody = "";
+            res.setEncoding("utf8");
+            res.on("data", chunk => {
+                responseBody += chunk;
+            });
+            res.on("end", () => resolve({ status: res.statusCode ?? 0, body: responseBody }));
+        });
+        req.on("error", reject);
+        req.end(body);
+    });
+}
+afterEach(async () => {
+    for (const child of running) {
+        if (!child.killed)
+            child.kill("SIGTERM");
+    }
+    running.clear();
+    while (mockGitLabServers.length > 0) {
+        const mockGitLab = mockGitLabServers.pop();
+        if (mockGitLab) {
+            await mockGitLab.stop();
+        }
+    }
+});
+describe("Streamable HTTP DNS rebinding protection", () => {
+    test("rejects forged Host and Origin headers before handling /mcp", async () => {
+        const port = await findAvailablePort(4700);
+        await startAuthenticatedServer({}, port);
+        await waitForHealth(port);
+        const validHost = hostWithPort(HOST, port);
+        const badJson = await postMcp(port, {
+            Host: "attacker.example.test",
+            Origin: `http://${validHost}`,
+        }, "{");
+        assert.equal(badJson.status, 403);
+        assert.match(badJson.body, /Host header is not allowed/);
+        assert.match(badJson.body, /MCP_ALLOWED_HOSTS/);
+        const badHost = await postMcp(port, {
+            Host: "attacker.example.test",
+            Origin: `http://${validHost}`,
+        });
+        assert.equal(badHost.status, 403);
+        assert.match(badHost.body, /Host header is not allowed/);
+        assert.match(badHost.body, /MCP_ALLOWED_HOSTS/);
+        const badOrigin = await postMcp(port, {
+            Host: validHost,
+            Origin: "https://attacker.example.test",
+        });
+        assert.equal(badOrigin.status, 403);
+        assert.match(badOrigin.body, /Origin header is not allowed/);
+        assert.match(badOrigin.body, /MCP_ALLOWED_ORIGINS/);
+        const ok = await postMcp(port, { Host: validHost });
+        assert.equal(ok.status, 200);
+    });
+    test("allows loopback Host and Origin on any port (Docker port mapping)", async () => {
+        const port = await findAvailablePort(4720);
+        await startAuthenticatedServer({}, port);
+        await waitForHealth(port);
+        // e.g. docker run -p 3333:3002 -> client sends Host: localhost:3333
+        const remappedHost = await postMcp(port, { Host: `localhost:${port + 1000}` });
+        assert.equal(remappedHost.status, 200);
+        const remappedIpv4 = await postMcp(port, { Host: `127.0.0.1:${port + 1000}` });
+        assert.equal(remappedIpv4.status, 200);
+        const remappedOrigin = await postMcp(port, {
+            Host: `localhost:${port + 1000}`,
+            Origin: `http://localhost:${port + 1000}`,
+        });
+        assert.equal(remappedOrigin.status, 200);
+        const bareLoopback = await postMcp(port, { Host: "localhost" });
+        assert.equal(bareLoopback.status, 200);
+        const loopbackHostBadOrigin = await postMcp(port, {
+            Host: `localhost:${port + 1000}`,
+            Origin: "http://attacker.example.test",
+        });
+        assert.equal(loopbackHostBadOrigin.status, 403);
+        assert.match(loopbackHostBadOrigin.body, /Origin header is not allowed/);
+        assert.match(loopbackHostBadOrigin.body, /MCP_ALLOWED_ORIGINS/);
+    });
+    test("allows the configured MCP_SERVER_URL host and origin", async () => {
+        const port = await findAvailablePort(4710);
+        await startAuthenticatedServer({ MCP_SERVER_URL: "https://mcp.example.test" }, port);
+        await waitForHealth(port);
+        const ok = await postMcp(port, {
+            Host: "mcp.example.test",
+            Origin: "https://mcp.example.test",
+        });
+        assert.equal(ok.status, 200);
+    });
+});

package/build/test/streamable-http-static-token-auth.test.js

@@ -4,7 +4,7 @@ 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 = "STREAMABLE_HTTP=true/--streamable-http with GITLAB_PERSONAL_ACCESS_TOKEN/--token or GITLAB_JOB_TOKEN/--job-token requires REMOTE_AUTHORIZATION=true/--remote-auth=true or GITLAB_MCP_OAUTH=true/--mcp-oauth=true";
+const ERROR_MESSAGE = "STREAMABLE_HTTP=true/--streamable-http with server-side GitLab credentials requires REMOTE_AUTHORIZATION=true/--remote-auth=true, GITLAB_MCP_OAUTH=true/--mcp-oauth=true, or STREAMABLE_HTTP_AUTH_TOKEN/--streamable-http-auth-token";
 const HOST = process.env.HOST || "127.0.0.1";
 const SERVER_PATH = path.resolve(process.cwd(), "build/index.js");
 const running = new Set();
@@ -69,11 +69,15 @@ async function waitForHealth(port, timeoutMs = 5000) {
     throw new Error(`server did not become healthy: ${String(lastError)}`);
 }
 async function postMcpWithoutAuth(port) {
+    return postMcp(port);
+}
+async function postMcp(port, token) {
     return fetch(`http://${HOST}:${port}/mcp`, {
         method: "POST",
         headers: {
             "Content-Type": "application/json",
             Accept: "application/json, text/event-stream",
+            ...(token ? { Authorization: `Bearer ${token}` } : {}),
         },
         body: JSON.stringify({
             jsonrpc: "2.0",
@@ -87,22 +91,6 @@ async function postMcpWithoutAuth(port) {
         }),
     });
 }
-async function postMcpWithSessionWithoutAuth(port, sessionId) {
-    return fetch(`http://${HOST}:${port}/mcp`, {
-        method: "POST",
-        headers: {
-            "Content-Type": "application/json",
-            Accept: "application/json, text/event-stream",
-            "Mcp-Session-Id": sessionId,
-        },
-        body: JSON.stringify({
-            jsonrpc: "2.0",
-            id: 2,
-            method: "tools/list",
-            params: {},
-        }),
-    });
-}
 afterEach(() => {
     for (const child of running) {
         if (!child.killed)
@@ -125,6 +113,13 @@ describe("Streamable HTTP static server token auth", () => {
         assert.notEqual(code, 0);
         assert.match(output, new RegExp(ERROR_MESSAGE.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")));
     });
+    test("refuses startup with cookie auth and no MCP-layer auth", async () => {
+        const port = await findAvailablePort(4315);
+        const child = startServer({ GITLAB_AUTH_COOKIE_PATH: "./cookies.txt" }, port);
+        const { code, output } = await waitForExit(child);
+        assert.notEqual(code, 0);
+        assert.match(output, new RegExp(ERROR_MESSAGE.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")));
+    });
     test("allows startup with PAT when REMOTE_AUTHORIZATION is enabled", async () => {
         const port = await findAvailablePort(4320);
         startServer({
@@ -133,11 +128,19 @@ describe("Streamable HTTP static server token auth", () => {
         }, port);
         await waitForHealth(port);
         const initResponse = await postMcpWithoutAuth(port);
-        assert.equal(initResponse.status, 200);
-        const sessionId = initResponse.headers.get("mcp-session-id");
-        assert.ok(sessionId);
-        const followUpResponse = await postMcpWithSessionWithoutAuth(port, sessionId);
-        assert.equal(followUpResponse.status, 401);
+        assert.equal(initResponse.status, 401);
+    });
+    test("requires configured Streamable HTTP auth token", async () => {
+        const port = await findAvailablePort(4325);
+        startServer({
+            GITLAB_PERSONAL_ACCESS_TOKEN: "glpat_test",
+            STREAMABLE_HTTP_AUTH_TOKEN: "mcp_static_secret",
+        }, port);
+        await waitForHealth(port);
+        const unauthenticated = await postMcpWithoutAuth(port);
+        assert.equal(unauthenticated.status, 401);
+        const authenticated = await postMcp(port, "mcp_static_secret");
+        assert.equal(authenticated.status, 200);
     });
     test("allows startup with PAT when GITLAB_MCP_OAUTH is enabled", async () => {
         const port = await findAvailablePort(4330);

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

@@ -36,24 +36,26 @@ async function rawMcpRequest(url, body, headers = {}) {
         text,
     };
 }
+const initializeBody = {
+    jsonrpc: "2.0",
+    id: 1,
+    method: "initialize",
+    params: {
+        protocolVersion: "2025-03-26",
+        capabilities: {},
+        clientInfo: { name: "unauth-discovery-test", version: "1.0.0" },
+    },
+};
 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" },
-        },
-    });
+    const response = await rawMcpRequest(mcpUrl, initializeBody);
     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);
+    // Keep above remote-auth-simple-test timeout suite (3500+) to avoid parallel bind races.
+    const port = await findAvailablePort(3600 + portOffset++ * 10);
     const server = await launchServer({
         mode: TransportMode.STREAMABLE_HTTP,
         port,
@@ -73,12 +75,23 @@ describe("Streamable HTTP unauthenticated tool discovery", { timeout: 20_000 },
         cleanupServers(servers);
         servers = [];
     });
-    test("keeps unauthenticated tools/list blocked by default", async () => {
+    test("keeps unauthenticated initialize 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);
+        const initResponse = await rawMcpRequest(mcpUrl, initializeBody);
+        assert.strictEqual(initResponse.status, 401, initResponse.text);
+        assert.strictEqual(initResponse.sessionId, null);
+    });
+    test("rejects invalid auth headers even when unauthenticated discovery is enabled", async () => {
+        const { server, mcpUrl } = await launchRemoteAuthServer({
+            GITLAB_ALLOW_UNAUTHENTICATED_TOOL_DISCOVERY: "true",
+        });
+        servers.push(server);
+        const initResponse = await rawMcpRequest(mcpUrl, initializeBody, {
+            Authorization: "Bearer definitely-not-valid",
+        });
+        assert.strictEqual(initResponse.status, 401, initResponse.text);
+        assert.strictEqual(initResponse.sessionId, null);
     });
     test("allows unauthenticated tools/list when explicitly enabled", async () => {
         const { server, mcpUrl } = await launchRemoteAuthServer({

package/build/test/test-ci-catalog.js

@@ -56,7 +56,7 @@ describe("CI/CD Catalog tools", () => {
         GITLAB_PERSONAL_ACCESS_TOKEN: MOCK_TOKEN,
     });
     before(async () => {
-        const port = await findMockServerPort(9000);
+        const port = await findMockServerPort();
         mockGitLab = new MockGitLabServer({ port, validTokens: [MOCK_TOKEN] });
         mockGitLab.addRootHandler("post", "/api/graphql", (req, res) => {
             if (req.body.query.includes("ListCiCatalogResources")) {

package/build/test/test-ci-lint.js

@@ -92,7 +92,7 @@ describe("GitLab CI lint tools", () => {
     let mockGitLab;
     let mockGitLabUrl;
     before(async () => {
-        const mockPort = await findMockServerPort(9260);
+        const mockPort = await findMockServerPort();
         mockGitLab = new MockGitLabServer({
             port: mockPort,
             validTokens: [MOCK_TOKEN],

package/build/test/test-ci-variables.js

@@ -77,12 +77,14 @@ async function callTool(toolName, args, env) {
 }
 describe("CI/CD variable tools", () => {
     let mockServer;
-    let mockPort;
+    let mockApiUrl;
     let baseEnv;
     let lastReceivedFilterScope;
     before(async () => {
-        mockPort = await findMockServerPort();
-        mockServer = new MockGitLabServer({ port: mockPort, validTokens: [MOCK_TOKEN] });
+        mockServer = new MockGitLabServer({
+            port: await findMockServerPort(),
+            validTokens: [MOCK_TOKEN],
+        });
         // --- Project variable endpoints ---
         mockServer.addMockHandler("get", `/projects/${TEST_PROJECT_ID}/variables`, (_req, res) => {
             res.json([MOCK_PROJECT_VARIABLE]);
@@ -124,9 +126,10 @@ describe("CI/CD variable tools", () => {
             res.status(204).send();
         });
         await mockServer.start();
+        mockApiUrl = `${mockServer.getUrl()}/api/v4`;
         baseEnv = {
             GITLAB_PERSONAL_ACCESS_TOKEN: MOCK_TOKEN,
-            GITLAB_API_URL: `http://localhost:${mockPort}/api/v4`,
+            GITLAB_API_URL: mockApiUrl,
             GITLAB_TOOLSETS: "variables",
         };
     });
@@ -245,7 +248,7 @@ describe("CI/CD variable tools", () => {
                 env: {
                     ...process.env,
                     GITLAB_PERSONAL_ACCESS_TOKEN: MOCK_TOKEN,
-                    GITLAB_API_URL: `http://localhost:${mockPort}/api/v4`,
+                    GITLAB_API_URL: mockApiUrl,
                     // No GITLAB_TOOLSETS — default toolsets only
                 },
             });

package/build/test/test-dependency-proxy.js

@@ -45,11 +45,16 @@ async function callTool(toolName, args, env) {
 }
 describe("dependency proxy tools", () => {
     let mockServer;
-    let mockPort;
+    let mockApiUrl;
     let baseEnv;
     before(async () => {
-        mockPort = await findMockServerPort();
-        mockServer = new MockGitLabServer({ port: mockPort, validTokens: [MOCK_TOKEN] });
+        mockServer = new MockGitLabServer({
+            port: await findMockServerPort(),
+            validTokens: [MOCK_TOKEN],
+        });
+        await mockServer.start();
+        const mockHost = new URL(mockServer.getUrl()).host;
+        mockApiUrl = `${mockServer.getUrl()}/api/v4`;
         // Mock GraphQL endpoint for get/list operations
         mockServer.addRootHandler("post", "/api/graphql", (req, res) => {
             const { query } = req.body;
@@ -63,7 +68,7 @@ describe("dependency proxy tools", () => {
                             dependencyProxySetting: { enabled: true },
                             dependencyProxyBlobCount: 3,
                             dependencyProxyTotalSize: "15728640",
-                            dependencyProxyImagePrefix: `localhost:${mockPort}/my-group/dependency_proxy/containers`,
+                            dependencyProxyImagePrefix: `${mockHost}/my-group/dependency_proxy/containers`,
                             dependencyProxyImageTtlPolicy: { enabled: true, ttl: 90 },
                         },
                     },
@@ -92,10 +97,9 @@ describe("dependency proxy tools", () => {
         mockServer.addMockHandler("delete", `/groups/${TEST_GROUP_PATH}/dependency_proxy/cache`, (_req, res) => {
             res.status(202).send();
         });
-        await mockServer.start();
         baseEnv = {
             GITLAB_PERSONAL_ACCESS_TOKEN: MOCK_TOKEN,
-            GITLAB_API_URL: `http://localhost:${mockPort}/api/v4`,
+            GITLAB_API_URL: mockApiUrl,
             GITLAB_TOOLSETS: "dependency_proxy",
         };
     });
@@ -135,7 +139,7 @@ describe("dependency proxy tools", () => {
                 env: {
                     ...process.env,
                     GITLAB_PERSONAL_ACCESS_TOKEN: MOCK_TOKEN,
-                    GITLAB_API_URL: `http://localhost:${mockPort}/api/v4`,
+                    GITLAB_API_URL: mockApiUrl,
                     // No GITLAB_TOOLSETS — default toolsets only
                 },
             });

package/build/test/test-deployment-tools.js

@@ -114,7 +114,7 @@ describe("deployment and environment tools", () => {
     let mockGitLab;
     let mockGitLabUrl;
     before(async () => {
-        const mockPort = await findMockServerPort(9300);
+        const mockPort = await findMockServerPort();
         mockGitLab = new MockGitLabServer({
             port: mockPort,
             validTokens: [MOCK_TOKEN],
@@ -318,11 +318,25 @@ describe("deployment and environment tools", () => {
         assert.strictEqual(result.name, "stage");
         assert.strictEqual(result.state, "available");
     });
-    test("get_merge_request returns compact deployment summary sorted by created_at desc", async () => {
+    test("get_merge_request omits summaries by default", async () => {
         const result = await callTool("get_merge_request", { project_id: TEST_PROJECT_ID, merge_request_iid: TEST_MERGE_REQUEST_IID }, {
             GITLAB_API_URL: `${mockGitLabUrl}/api/v4`,
             GITLAB_PERSONAL_ACCESS_TOKEN: MOCK_TOKEN,
         });
+        assert.strictEqual(result.iid, TEST_MERGE_REQUEST_IID);
+        assert.strictEqual(result.deployment_summary, undefined, "deployment_summary should be omitted by default");
+        assert.strictEqual(result.commit_addition_summary, undefined, "commit_addition_summary should be omitted by default");
+        assert.strictEqual(result.approval_summary, undefined, "approval_summary should be omitted by default");
+    });
+    test("get_merge_request returns compact deployment summary sorted by created_at desc", async () => {
+        const result = await callTool("get_merge_request", {
+            project_id: TEST_PROJECT_ID,
+            merge_request_iid: TEST_MERGE_REQUEST_IID,
+            include_summaries: true,
+        }, {
+            GITLAB_API_URL: `${mockGitLabUrl}/api/v4`,
+            GITLAB_PERSONAL_ACCESS_TOKEN: MOCK_TOKEN,
+        });
         assert.ok(result.deployment_summary, "deployment_summary should be present");
         assert.strictEqual(result.diverged_commits_count, TEST_DIVERGED_COMMITS_COUNT, "diverged_commits_count should be requested and returned by default");
         assert.strictEqual(result.deployment_summary.lookup_sha, TEST_MERGE_REQUEST_SHA);

package/build/test/test-download-attachment.js

@@ -60,7 +60,7 @@ describe('download_attachment', () => {
     let mockGitLab;
     let env;
     before(async () => {
-        const port = await findMockServerPort(9100);
+        const port = await findMockServerPort();
         mockGitLab = new MockGitLabServer({ port, validTokens: [MOCK_TOKEN] });
         await mockGitLab.start();
         env = {

package/build/test/test-get-file-blame.js

@@ -72,7 +72,7 @@ describe("get_file_blame", () => {
     let mockGitLabUrl;
     let lastQuery = {};
     before(async () => {
-        const mockPort = await findMockServerPort(9000);
+        const mockPort = await findMockServerPort();
         mockGitLab = new MockGitLabServer({
             port: mockPort,
             validTokens: [MOCK_TOKEN],