@zereight/mcp-gitlab 2.1.42 → 2.1.44

package/build/scripts/generate-tool-docs.js

@@ -115,6 +115,10 @@ const GROUP_META = {
         title: "Dependency Proxy",
         blurb: "Inspect and manage the GitLab dependency proxy cache settings, blob storage, and purge operations.",
     },
+    vulnerabilities: {
+        title: "Vulnerabilities",
+        blurb: "AI-assisted vulnerability triage — list findings, inspect details, dismiss with reason, or confirm for remediation. Backed by the GitLab GraphQL API; requires GitLab Ultimate.",
+    },
 };
 const GROUP_ORDER = [
     "projects",
@@ -136,6 +140,7 @@ const GROUP_ORDER = [
     "webhooks",
     "search",
     "dependency_proxy",
+    "vulnerabilities",
 ];
 // Authoritative classification — uses the `readOnlyTools` set from
 // tools/registry.ts. That set is what the server itself consults to decide
@@ -210,7 +215,7 @@ function buildGroupPage(id, toolNames) {
     lines.push("## Tools in this group");
     lines.push("");
     for (const name of toolNames) {
-        lines.push(`- [\`${name}\`](#${name.replace(/_/g, "_")}) — ${rwBadge(name)}`);
+        lines.push(`- [\`${name}\`](#${name}) — ${rwBadge(name)}`);
     }
     lines.push("");
     lines.push("---");

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

@@ -26,6 +26,7 @@ describe("Dynamic API URL allowlist", () => {
     let secondaryGitLab;
     let attackerServer;
     let mcpServer;
+    let mcpPort;
     let mcpUrl;
     let secondaryHit = false;
     let getAttackerHits = () => 0;
@@ -44,7 +45,7 @@ describe("Dynamic API URL allowlist", () => {
         const attacker = await startAttackerServer(attackerPort);
         attackerServer = attacker.server;
         getAttackerHits = attacker.getHits;
-        const mcpPort = await findAvailablePort(3100);
+        mcpPort = await findAvailablePort(3100);
         mcpServer = await launchServer({
             mode: TransportMode.STREAMABLE_HTTP,
             port: mcpPort,
@@ -101,4 +102,20 @@ describe("Dynamic API URL allowlist", () => {
         assert.strictEqual(connected, false, "untrusted dynamic host should not initialize a session");
         assert.strictEqual(getAttackerHits(), 0, "token-bearing requests must not reach untrusted hosts");
     });
+    test("returns remediation text when download proxy rejects untrusted dynamic hosts", async () => {
+        const server = attackerServer;
+        assert.ok(server, "attacker server should be running");
+        const attackerUrl = `http://${HOST}:${server.address().port}/api/v4`;
+        const response = await fetch(`http://${HOST}:${mcpPort}/downloads/job-artifacts?project_id=1&job_id=1`, {
+            headers: {
+                "Private-Token": MOCK_TOKEN,
+                "x-gitlab-api-url": attackerUrl,
+            },
+        });
+        assert.strictEqual(response.status, 400);
+        const body = (await response.json());
+        assert.match(body.error, /not allowed/);
+        assert.match(body.error, /GITLAB_ALLOWED_HOSTS/);
+        assert.strictEqual(getAttackerHits(), 0, "download proxy must not forward to untrusted hosts");
+    });
 });

package/build/test/test-health-check.js

@@ -0,0 +1,106 @@
+import { describe, test } from "node:test";
+import assert from "node:assert";
+import { spawn } from "child_process";
+import { MockGitLabServer, findMockServerPort } from "./utils/mock-gitlab-server.js";
+const MOCK_TOKEN = "glpat-mock-token-12345";
+function createMockGitLabServer(port) {
+    return new MockGitLabServer({
+        port,
+        validTokens: [MOCK_TOKEN],
+    });
+}
+function baseEnv(mockGitLabUrl) {
+    return {
+        GITLAB_API_URL: `${mockGitLabUrl}/api/v4`,
+        GITLAB_PERSONAL_ACCESS_TOKEN: MOCK_TOKEN,
+        GITLAB_TOOLSETS: "projects",
+    };
+}
+async function callHealthCheckAsync(env) {
+    return new Promise((resolve, reject) => {
+        const proc = spawn("node", ["build/index.js"], {
+            stdio: ["pipe", "pipe", "pipe"],
+            env: {
+                ...process.env,
+                ...env,
+                USE_PIPELINE: "true",
+            },
+        });
+        let output = "";
+        let errorOutput = "";
+        proc.stdout?.on("data", (chunk) => (output += chunk));
+        proc.stderr?.on("data", (chunk) => (errorOutput += chunk));
+        proc.on("close", code => {
+            if (code !== 0) {
+                return reject(new Error(`Process exited with code ${code}: ${errorOutput}`));
+            }
+            const line = output.split("\n").find(entry => entry.startsWith("{"));
+            if (!line) {
+                return reject(new Error("No JSON output found"));
+            }
+            try {
+                const response = JSON.parse(line);
+                if (response.error) {
+                    reject(response.error);
+                    return;
+                }
+                const content = response.result?.content?.[0]?.text;
+                if (!content) {
+                    reject(new Error("No tool result content"));
+                    return;
+                }
+                resolve(JSON.parse(content));
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+        proc.stdin?.end(JSON.stringify({
+            jsonrpc: "2.0",
+            id: 1,
+            method: "tools/call",
+            params: { name: "health_check", arguments: {} },
+        }) + "\n");
+    });
+}
+describe("When health_check runs", () => {
+    describe("with authenticated mock GitLab", () => {
+        test("should include GitLab instance version metadata", async () => {
+            const mockPort = await findMockServerPort();
+            const mockGitLab = createMockGitLabServer(mockPort);
+            await mockGitLab.start();
+            try {
+                const result = await callHealthCheckAsync(baseEnv(mockGitLab.getUrl()));
+                assert.equal(result.status, "ok");
+                assert.equal(result.authenticated, true);
+                assert.equal(result.version, "18.3.1-ee");
+                assert.equal(result.revision, "abc1234");
+                assert.equal(result.enterprise, true);
+            }
+            finally {
+                await mockGitLab.stop();
+            }
+        });
+    });
+    describe("when GitLab /version lookup fails", () => {
+        test("should keep health check ok without version fields", async () => {
+            const mockPort = await findMockServerPort();
+            const mockGitLab = createMockGitLabServer(mockPort);
+            mockGitLab.addMockHandler("get", "/version", (_req, res) => {
+                res.status(500).json({ message: "version unavailable" });
+            });
+            await mockGitLab.start();
+            try {
+                const result = await callHealthCheckAsync(baseEnv(mockGitLab.getUrl()));
+                assert.equal(result.status, "ok");
+                assert.equal(result.authenticated, true);
+                assert.equal("version" in result, false);
+                assert.equal("revision" in result, false);
+                assert.equal("enterprise" in result, false);
+            }
+            finally {
+                await mockGitLab.stop();
+            }
+        });
+    });
+});

package/build/test/test-toolset-filtering.js

@@ -35,6 +35,7 @@ const TOOLSET_TOOL_COUNTS = {
     groups: 1,
     variables: 10,
     dependency_proxy: 4,
+    vulnerabilities: 4,
 };
 const LEGACY_PIPELINE_CI_TOOL_COUNT = 2;
 const LEGACY_PIPELINE_TOOL_COUNT = TOOLSET_TOOL_COUNTS.pipelines + LEGACY_PIPELINE_CI_TOOL_COUNT;
@@ -60,6 +61,7 @@ const NON_DEFAULT_TOOLSETS = [
     "search",
     "variables",
     "dependency_proxy",
+    "vulnerabilities",
 ];
 // discover_tools meta-tool is always force-injected (Step 5.5)
 const DISCOVER_TOOLS_COUNT = 1;

package/build/test/test-vulnerabilities.js

@@ -0,0 +1,399 @@
+import { describe, test, before, after } from "node:test";
+import assert from "node:assert";
+import { spawn } from "child_process";
+import { MockGitLabServer, findMockServerPort } from "./utils/mock-gitlab-server.js";
+const MOCK_TOKEN = "glpat-mock-token-12345";
+const TEST_PROJECT_ID = "456";
+const TEST_PROJECT_FULL_PATH = "test-group/test-project";
+const TEST_VULNERABILITY_ID = "789";
+const TEST_VULNERABILITY_GID = `gid://gitlab/Vulnerability/${TEST_VULNERABILITY_ID}`;
+const mockVulnerability = {
+    id: TEST_VULNERABILITY_GID,
+    title: "Hard-coded credential detected",
+    description: "A hard-coded credential was found in source code",
+    state: "DETECTED",
+    severity: "CRITICAL",
+    reportType: "SECRET_DETECTION",
+    detectedAt: "2024-06-01T10:00:00Z",
+    confirmedAt: null,
+    resolvedAt: null,
+    dismissedAt: null,
+    dismissalReason: null,
+    webUrl: "https://gitlab.mock/test-group/test-project/-/security/vulnerabilities/789",
+    scanner: { name: "GitLeaks", externalId: "gitleaks", vendor: "GitLab" },
+    identifiers: [
+        { externalType: "cve", externalId: "CVE-2024-0001", name: "CVE-2024-0001", url: null },
+    ],
+    links: [{ name: "More info", url: "https://example.com/vuln/789" }],
+    location: { file: "config/secrets.yml", startLine: 42, endLine: 42 },
+};
+const mockVulnerabilityList = [
+    mockVulnerability,
+    {
+        ...mockVulnerability,
+        id: "gid://gitlab/Vulnerability/790",
+        title: "SQL Injection in login form",
+        state: "CONFIRMED",
+        severity: "HIGH",
+        reportType: "SAST",
+        confirmedAt: "2024-06-03T09:00:00Z",
+        location: { file: "src/auth/login.ts", startLine: 18, endLine: 22 },
+    },
+    {
+        ...mockVulnerability,
+        id: "gid://gitlab/Vulnerability/791",
+        title: "Outdated dependency with known CVE",
+        state: "DISMISSED",
+        severity: "MEDIUM",
+        reportType: "DEPENDENCY_SCANNING",
+        dismissedAt: "2024-05-20T14:00:00Z",
+        dismissalReason: "ACCEPTABLE_RISK",
+        location: { file: "package.json", dependency: { package: { name: "foo" }, version: "1.2.3" } },
+    },
+];
+async function callTool(toolName, args, env) {
+    return new Promise((resolve, reject) => {
+        const proc = spawn("node", ["build/index.js"], {
+            stdio: ["pipe", "pipe", "pipe"],
+            env: {
+                ...process.env,
+                ...env,
+                USE_PIPELINE: "true",
+            },
+        });
+        let output = "";
+        let errorOutput = "";
+        proc.stdout?.on("data", (d) => (output += d));
+        proc.stderr?.on("data", (d) => (errorOutput += d));
+        proc.on("close", code => {
+            if (code !== 0) {
+                return reject(new Error(`Process exited with code ${code}: ${errorOutput}`));
+            }
+            const line = output.split("\n").find(l => l.startsWith("{"));
+            if (!line) {
+                return reject(new Error("No JSON output found"));
+            }
+            try {
+                const response = JSON.parse(line);
+                if (response.error) {
+                    reject(response.error);
+                }
+                else {
+                    const content = response.result?.content?.[0]?.text;
+                    if (content) {
+                        try {
+                            resolve(JSON.parse(content));
+                        }
+                        catch {
+                            resolve(content);
+                        }
+                    }
+                    else {
+                        resolve(response.result);
+                    }
+                }
+            }
+            catch (e) {
+                reject(e);
+            }
+        });
+        proc.stdin?.end(JSON.stringify({
+            jsonrpc: "2.0",
+            id: 1,
+            method: "tools/call",
+            params: { name: toolName, arguments: args },
+        }) + "\n");
+    });
+}
+describe("vulnerability tools", () => {
+    let mockGitLab;
+    let mockGitLabUrl;
+    // Capture variables for verifying GraphQL payloads
+    let lastListVariables = null;
+    let lastDismissInput = null;
+    let lastConfirmInput = null;
+    let lastGetId = null;
+    const baseEnv = () => ({
+        GITLAB_API_URL: `${mockGitLabUrl}/api/v4`,
+        GITLAB_PERSONAL_ACCESS_TOKEN: MOCK_TOKEN,
+        GITLAB_TOOLSETS: "vulnerabilities",
+    });
+    before(async () => {
+        const mockPort = await findMockServerPort();
+        mockGitLab = new MockGitLabServer({
+            port: mockPort,
+            validTokens: [MOCK_TOKEN],
+        });
+        // All four tools go through POST /api/graphql; dispatch on operation name
+        mockGitLab.addRootHandler("post", "/api/graphql", (req, res) => {
+            const query = req.body.query || "";
+            const variables = req.body.variables || {};
+            if (query.includes("vulnerabilityDismiss")) {
+                lastDismissInput = variables.input;
+                res.json({
+                    data: {
+                        vulnerabilityDismiss: {
+                            vulnerability: {
+                                id: TEST_VULNERABILITY_GID,
+                                state: "DISMISSED",
+                                dismissedAt: "2024-06-10T12:00:00Z",
+                                dismissalReason: variables.input?.dismissalReason || null,
+                            },
+                            errors: [],
+                        },
+                    },
+                });
+                return;
+            }
+            if (query.includes("vulnerabilityConfirm")) {
+                lastConfirmInput = variables.input;
+                res.json({
+                    data: {
+                        vulnerabilityConfirm: {
+                            vulnerability: {
+                                id: TEST_VULNERABILITY_GID,
+                                state: "CONFIRMED",
+                                confirmedAt: "2024-06-10T12:00:00Z",
+                            },
+                            errors: [],
+                        },
+                    },
+                });
+                return;
+            }
+            if (query.includes("listProjectVulnerabilities")) {
+                lastListVariables = variables;
+                let nodes = mockVulnerabilityList;
+                if (variables.state) {
+                    nodes = nodes.filter(v => variables.state.includes(v.state));
+                }
+                if (variables.severity) {
+                    nodes = nodes.filter(v => variables.severity.includes(v.severity));
+                }
+                if (variables.reportType) {
+                    nodes = nodes.filter(v => variables.reportType.includes(v.reportType));
+                }
+                res.json({
+                    data: {
+                        project: {
+                            vulnerabilities: {
+                                nodes,
+                                pageInfo: { endCursor: "cursor-abc", hasNextPage: false },
+                            },
+                        },
+                    },
+                });
+                return;
+            }
+            if (query.includes("getVulnerability")) {
+                lastGetId = variables.id;
+                res.json({
+                    data: {
+                        vulnerability: {
+                            ...mockVulnerability,
+                            project: {
+                                id: "gid://gitlab/Project/456",
+                                name: "Test Project",
+                                fullPath: TEST_PROJECT_FULL_PATH,
+                            },
+                        },
+                    },
+                });
+                return;
+            }
+            res
+                .status(400)
+                .json({ errors: [{ message: `Unexpected GraphQL query: ${query.slice(0, 80)}` }] });
+        });
+        await mockGitLab.start();
+        mockGitLabUrl = mockGitLab.getUrl();
+    });
+    after(async () => {
+        await mockGitLab.stop();
+    });
+    test("list_project_vulnerabilities returns vulnerabilities with pageInfo", async () => {
+        const result = await callTool("list_project_vulnerabilities", { project_id: TEST_PROJECT_ID }, baseEnv());
+        assert.ok(Array.isArray(result.vulnerabilities), "Response should contain vulnerabilities array");
+        assert.strictEqual(result.vulnerabilities.length, 3, "Should return 3 vulnerabilities");
+        assert.strictEqual(result.vulnerabilities[0].id, TEST_VULNERABILITY_GID);
+        assert.strictEqual(result.vulnerabilities[0].title, "Hard-coded credential detected");
+        assert.ok(result.pageInfo, "Response should include pageInfo for cursor pagination");
+        assert.strictEqual(result.pageInfo.hasNextPage, false);
+    });
+    test("list_project_vulnerabilities resolves numeric project ID to full path", async () => {
+        lastListVariables = null;
+        await callTool("list_project_vulnerabilities", { project_id: TEST_PROJECT_ID }, baseEnv());
+        assert.ok(lastListVariables, "GraphQL variables should have been captured");
+        assert.strictEqual(lastListVariables.fullPath, TEST_PROJECT_FULL_PATH, "Numeric project ID should be resolved to the project full path");
+    });
+    test("list_project_vulnerabilities passes state filter as GraphQL enum", async () => {
+        lastListVariables = null;
+        const result = await callTool("list_project_vulnerabilities", { project_id: TEST_PROJECT_ID, state: "detected" }, baseEnv());
+        assert.ok(lastListVariables, "GraphQL variables should have been captured");
+        assert.deepStrictEqual(lastListVariables.state, ["DETECTED"], "state should be uppercased enum array");
+        assert.strictEqual(result.vulnerabilities.length, 1, "Mock should filter to only DETECTED");
+    });
+    test("list_project_vulnerabilities passes severity filter as GraphQL enum", async () => {
+        lastListVariables = null;
+        const result = await callTool("list_project_vulnerabilities", { project_id: TEST_PROJECT_ID, severity: "critical" }, baseEnv());
+        assert.ok(lastListVariables, "GraphQL variables should have been captured");
+        assert.deepStrictEqual(lastListVariables.severity, ["CRITICAL"]);
+        assert.strictEqual(result.vulnerabilities.length, 1, "Mock should filter to only CRITICAL");
+    });
+    test("list_project_vulnerabilities passes report_type filter as GraphQL enum", async () => {
+        lastListVariables = null;
+        const result = await callTool("list_project_vulnerabilities", { project_id: TEST_PROJECT_ID, report_type: "secret_detection" }, baseEnv());
+        assert.ok(lastListVariables, "GraphQL variables should have been captured");
+        assert.deepStrictEqual(lastListVariables.reportType, ["SECRET_DETECTION"]);
+        assert.strictEqual(result.vulnerabilities.length, 1, "Mock should filter to only SECRET_DETECTION");
+    });
+    test("list_project_vulnerabilities forwards cursor pagination", async () => {
+        lastListVariables = null;
+        await callTool("list_project_vulnerabilities", { project_id: TEST_PROJECT_ID, first: 50, after: "cursor-abc" }, baseEnv());
+        assert.ok(lastListVariables, "GraphQL variables should have been captured");
+        assert.strictEqual(lastListVariables.first, 50);
+        assert.strictEqual(lastListVariables.after, "cursor-abc");
+    });
+    test("get_vulnerability returns full vulnerability object via GID", async () => {
+        lastGetId = null;
+        const result = await callTool("get_vulnerability", { vulnerability_id: TEST_VULNERABILITY_ID }, baseEnv());
+        assert.strictEqual(lastGetId, TEST_VULNERABILITY_GID, "Numeric ID should be converted to a GraphQL global ID");
+        assert.strictEqual(result.id, TEST_VULNERABILITY_GID);
+        assert.strictEqual(result.title, "Hard-coded credential detected");
+        assert.strictEqual(result.description, "A hard-coded credential was found in source code");
+        assert.strictEqual(result.state, "DETECTED");
+        assert.strictEqual(result.severity, "CRITICAL");
+        assert.strictEqual(result.reportType, "SECRET_DETECTION");
+        assert.strictEqual(result.location.file, "config/secrets.yml");
+        assert.strictEqual(result.location.startLine, 42);
+        assert.strictEqual(result.identifiers[0].name, "CVE-2024-0001");
+        assert.strictEqual(result.links[0].url, "https://example.com/vuln/789");
+        assert.strictEqual(result.project.fullPath, TEST_PROJECT_FULL_PATH);
+    });
+    test("dismiss_vulnerability sends dismissalReason in mutation input", async () => {
+        lastDismissInput = null;
+        const result = await callTool("dismiss_vulnerability", { vulnerability_id: TEST_VULNERABILITY_ID, reason: "false_positive" }, baseEnv());
+        assert.ok(lastDismissInput, "Mutation input should have been captured");
+        assert.strictEqual(lastDismissInput.id, TEST_VULNERABILITY_GID);
+        assert.strictEqual(lastDismissInput.dismissalReason, "FALSE_POSITIVE", "Reason should be mapped to the GraphQL enum");
+        assert.strictEqual(result.state, "DISMISSED");
+        assert.strictEqual(result.dismissalReason, "FALSE_POSITIVE");
+    });
+    test("dismiss_vulnerability includes comment when provided", async () => {
+        lastDismissInput = null;
+        await callTool("dismiss_vulnerability", {
+            vulnerability_id: TEST_VULNERABILITY_ID,
+            reason: "acceptable_risk",
+            comment: "Reviewed by security team, risk accepted",
+        }, baseEnv());
+        assert.ok(lastDismissInput, "Mutation input should have been captured");
+        assert.strictEqual(lastDismissInput.dismissalReason, "ACCEPTABLE_RISK");
+        assert.strictEqual(lastDismissInput.comment, "Reviewed by security team, risk accepted");
+    });
+    test("dismiss_vulnerability accepts mitigating_control and not_applicable reasons", async () => {
+        lastDismissInput = null;
+        await callTool("dismiss_vulnerability", { vulnerability_id: TEST_VULNERABILITY_ID, reason: "mitigating_control" }, baseEnv());
+        assert.strictEqual(lastDismissInput.dismissalReason, "MITIGATING_CONTROL");
+        lastDismissInput = null;
+        await callTool("dismiss_vulnerability", { vulnerability_id: TEST_VULNERABILITY_ID, reason: "not_applicable" }, baseEnv());
+        assert.strictEqual(lastDismissInput.dismissalReason, "NOT_APPLICABLE");
+    });
+    test("confirm_vulnerability sends mutation with GID", async () => {
+        lastConfirmInput = null;
+        const result = await callTool("confirm_vulnerability", { vulnerability_id: TEST_VULNERABILITY_ID }, baseEnv());
+        assert.ok(lastConfirmInput, "Mutation input should have been captured");
+        assert.strictEqual(lastConfirmInput.id, TEST_VULNERABILITY_GID);
+        assert.strictEqual(result.state, "CONFIRMED");
+        assert.strictEqual(result.confirmedAt, "2024-06-10T12:00:00Z");
+    });
+    test("confirm_vulnerability includes comment when provided", async () => {
+        lastConfirmInput = null;
+        await callTool("confirm_vulnerability", {
+            vulnerability_id: TEST_VULNERABILITY_ID,
+            comment: "Confirmed after manual verification",
+        }, baseEnv());
+        assert.ok(lastConfirmInput, "Mutation input should have been captured");
+        assert.strictEqual(lastConfirmInput.comment, "Confirmed after manual verification");
+    });
+    // Read-only mode tests
+    test("read-only mode: list_project_vulnerabilities succeeds", async () => {
+        const result = await callTool("list_project_vulnerabilities", { project_id: TEST_PROJECT_ID }, { ...baseEnv(), GITLAB_PERMISSION_MODE: "readonly" });
+        assert.ok(Array.isArray(result.vulnerabilities), "Should return vulnerabilities in readonly mode");
+        assert.strictEqual(result.vulnerabilities.length, 3);
+    });
+    test("read-only mode: get_vulnerability succeeds", async () => {
+        const result = await callTool("get_vulnerability", { vulnerability_id: TEST_VULNERABILITY_ID }, { ...baseEnv(), GITLAB_PERMISSION_MODE: "readonly" });
+        assert.strictEqual(result.id, TEST_VULNERABILITY_GID);
+        assert.strictEqual(result.title, "Hard-coded credential detected");
+    });
+    test("read-only mode: dismiss_vulnerability is rejected", async () => {
+        await assert.rejects(() => callTool("dismiss_vulnerability", { vulnerability_id: TEST_VULNERABILITY_ID, reason: "false_positive" }, { ...baseEnv(), GITLAB_PERMISSION_MODE: "readonly" }), (err) => {
+            const msg = typeof err === "string" ? err : err?.message || JSON.stringify(err);
+            assert.ok(msg.toLowerCase().includes("not allowed") ||
+                msg.toLowerCase().includes("read-only") ||
+                msg.toLowerCase().includes("readonly") ||
+                msg.toLowerCase().includes("not available"), `Expected read-only rejection, got: ${msg}`);
+            return true;
+        });
+    });
+    test("read-only mode: confirm_vulnerability is rejected", async () => {
+        await assert.rejects(() => callTool("confirm_vulnerability", { vulnerability_id: TEST_VULNERABILITY_ID }, { ...baseEnv(), GITLAB_PERMISSION_MODE: "readonly" }), (err) => {
+            const msg = typeof err === "string" ? err : err?.message || JSON.stringify(err);
+            assert.ok(msg.toLowerCase().includes("not allowed") ||
+                msg.toLowerCase().includes("read-only") ||
+                msg.toLowerCase().includes("readonly") ||
+                msg.toLowerCase().includes("not available"), `Expected read-only rejection, got: ${msg}`);
+            return true;
+        });
+    });
+    // GITLAB_ALLOWED_PROJECT_IDS tests: the mock vulnerability belongs to
+    // project 456 (test-group/test-project), so an allowlist of "999" must
+    // deny all id-only vulnerability tools.
+    const assertAccessDenied = (err) => {
+        const msg = typeof err === "string" ? err : err?.message || JSON.stringify(err);
+        assert.ok(msg.includes("Access denied"), `Expected allowlist rejection, got: ${msg}`);
+        return true;
+    };
+    test("allowlist: get_vulnerability is rejected for a vulnerability outside allowed projects", async () => {
+        await assert.rejects(() => callTool("get_vulnerability", { vulnerability_id: TEST_VULNERABILITY_ID }, { ...baseEnv(), GITLAB_ALLOWED_PROJECT_IDS: "999" }), assertAccessDenied);
+    });
+    test("allowlist: get_vulnerability succeeds when project is allowed by numeric ID", async () => {
+        const result = await callTool("get_vulnerability", { vulnerability_id: TEST_VULNERABILITY_ID }, { ...baseEnv(), GITLAB_ALLOWED_PROJECT_IDS: TEST_PROJECT_ID });
+        assert.strictEqual(result.id, TEST_VULNERABILITY_GID);
+    });
+    test("allowlist: get_vulnerability succeeds when project is allowed by full path", async () => {
+        const result = await callTool("get_vulnerability", { vulnerability_id: TEST_VULNERABILITY_ID }, { ...baseEnv(), GITLAB_ALLOWED_PROJECT_IDS: `999,${TEST_PROJECT_FULL_PATH}` });
+        assert.strictEqual(result.id, TEST_VULNERABILITY_GID);
+    });
+    test("allowlist: dismiss_vulnerability is rejected before the mutation is sent", async () => {
+        lastDismissInput = null;
+        await assert.rejects(() => callTool("dismiss_vulnerability", { vulnerability_id: TEST_VULNERABILITY_ID, reason: "false_positive" }, { ...baseEnv(), GITLAB_ALLOWED_PROJECT_IDS: "999" }), assertAccessDenied);
+        assert.strictEqual(lastDismissInput, null, "vulnerabilityDismiss mutation must not be sent for a denied project");
+    });
+    test("allowlist: confirm_vulnerability is rejected before the mutation is sent", async () => {
+        lastConfirmInput = null;
+        await assert.rejects(() => callTool("confirm_vulnerability", { vulnerability_id: TEST_VULNERABILITY_ID }, { ...baseEnv(), GITLAB_ALLOWED_PROJECT_IDS: "999" }), assertAccessDenied);
+        assert.strictEqual(lastConfirmInput, null, "vulnerabilityConfirm mutation must not be sent for a denied project");
+    });
+    test("allowlist: dismiss_vulnerability succeeds when the vulnerability's project is allowed", async () => {
+        lastDismissInput = null;
+        const result = await callTool("dismiss_vulnerability", { vulnerability_id: TEST_VULNERABILITY_ID, reason: "false_positive" }, { ...baseEnv(), GITLAB_ALLOWED_PROJECT_IDS: TEST_PROJECT_ID });
+        assert.ok(lastDismissInput, "Mutation should be sent after the allowlist check passes");
+        assert.strictEqual(lastDismissInput.id, TEST_VULNERABILITY_GID);
+        assert.strictEqual(result.state, "DISMISSED");
+    });
+    // GID validation tests: only numeric IDs and Vulnerability GIDs are accepted
+    const assertInvalidVulnerabilityId = (err) => {
+        const msg = typeof err === "string" ? err : err?.message || JSON.stringify(err);
+        assert.ok(msg.includes("Invalid vulnerability ID"), `Expected invalid-ID rejection, got: ${msg}`);
+        return true;
+    };
+    test("gid validation: get_vulnerability rejects non-Vulnerability GIDs", async () => {
+        await assert.rejects(() => callTool("get_vulnerability", { vulnerability_id: "gid://gitlab/Project/456" }, baseEnv()), assertInvalidVulnerabilityId);
+    });
+    test("gid validation: dismiss_vulnerability rejects a non-numeric ID before any request", async () => {
+        lastDismissInput = null;
+        await assert.rejects(() => callTool("dismiss_vulnerability", { vulnerability_id: "not-a-vuln-id", reason: "false_positive" }, baseEnv()), assertInvalidVulnerabilityId);
+        assert.strictEqual(lastDismissInput, null, "vulnerabilityDismiss mutation must not be sent for an invalid ID");
+    });
+});

package/build/test/utils/gitlab-instance-version.test.js

@@ -0,0 +1,32 @@
+import assert from "node:assert/strict";
+import { describe, test } from "node:test";
+import { parseGitLabVersionApiResponse } from "../../utils/gitlab-instance-version.js";
+describe("When parseGitLabVersionApiResponse runs", () => {
+    describe("with a full GitLab /version payload", () => {
+        test("should return version, revision, and enterprise", () => {
+            assert.deepEqual(parseGitLabVersionApiResponse({
+                version: "18.3.1-ee",
+                revision: "abc1234",
+                enterprise: true,
+            }), {
+                version: "18.3.1-ee",
+                revision: "abc1234",
+                enterprise: true,
+            });
+        });
+    });
+    describe("with only a version field", () => {
+        test("should return version without optional fields", () => {
+            assert.deepEqual(parseGitLabVersionApiResponse({ version: "17.5.0" }), {
+                version: "17.5.0",
+            });
+        });
+    });
+    describe("with invalid payloads", () => {
+        test("should return null", () => {
+            assert.equal(parseGitLabVersionApiResponse(null), null);
+            assert.equal(parseGitLabVersionApiResponse({}), null);
+            assert.equal(parseGitLabVersionApiResponse({ version: 18 }), null);
+        });
+    });
+});

package/build/test/utils/mock-gitlab-server.js

@@ -150,6 +150,14 @@ export class MockGitLabServer {
                 state: "active",
             });
         });
+        // GET /api/v4/version - GitLab instance version
+        this.app.get("/api/v4/version", (_req, res) => {
+            res.json({
+                version: "18.3.1-ee",
+                revision: "abc1234",
+                enterprise: true,
+            });
+        });
         // GET /api/v4/projects/:projectId - Get project
         this.app.get("/api/v4/projects/:projectId", (req, res) => {
             const projectId = req.params.projectId;