@zereight/mcp-gitlab 2.1.41 → 2.1.43

package/build/schemas.js

@@ -2547,26 +2547,31 @@ export const MergeRequestThreadPositionSchema = z.object({
 });
 const optionalMergeRequestThreadPosition = z.preprocess(omitIncompleteMergeRequestPosition, MergeRequestThreadPositionSchema.optional());
 // Draft Notes API schemas
+// Response shape follows Draft Notes API (not Notes API): note, author_id,
+// line_code, merge_request_id, commit_id — no created_at/updated_at.
 export const GitLabDraftNoteSchema = z
     .object({
     id: z.coerce.string(),
+    author_id: z.coerce.number().nullable().optional(),
     author: GitLabUserSchema.optional(),
     body: z.string().optional(),
-    note: z.string().optional(), // Some APIs might use 'note' instead of 'body'
-    created_at: z.string().optional(),
-    updated_at: z.string().optional(),
+    note: z.string().optional(), // Draft Notes API uses 'note'; keep 'body' for callers
+    line_code: z.string().nullable().optional(),
+    merge_request_id: z.coerce.number().nullable().optional(),
+    commit_id: z.string().nullable().optional(),
     discussion_id: z.string().nullable().optional(),
     position: z.record(z.unknown()).nullable().optional(),
     resolve_discussion: z.coerce.boolean().optional(),
 })
     .transform(data => ({
-    // Normalize the response to always have consistent field names
     id: data.id,
+    author_id: data.author_id ?? null,
     author: data.author,
     body: data.body || data.note || "",
-    created_at: data.created_at || "",
-    updated_at: data.updated_at || "",
-    discussion_id: data.discussion_id || null,
+    line_code: data.line_code ?? null,
+    merge_request_id: data.merge_request_id ?? null,
+    commit_id: data.commit_id ?? null,
+    discussion_id: data.discussion_id ?? null,
     position: data.position,
     resolve_discussion: data.resolve_discussion,
 }));
@@ -2617,6 +2622,18 @@ export const PublishDraftNoteSchema = ProjectParamsSchema.extend({
 // Bulk publish draft notes schema
 export const BulkPublishDraftNotesSchema = ProjectParamsSchema.extend({
     merge_request_iid: z.coerce.string().describe("The IID of a merge request"),
+    reviewer_state: z
+        .enum(["requested_changes", "reviewed"])
+        .optional()
+        .describe("Set reviewer review state after publishing (GitLab 19.2+). Does not record a formal approval. Works even with no draft notes."),
+    note: z
+        .string()
+        .optional()
+        .describe("Summary note body to post on the merge request (GitLab 19.2+)"),
+    internal: z.coerce
+        .boolean()
+        .optional()
+        .describe("If true, the summary note is internal (GitLab 19.2+, default false)"),
 });
 // Schema for creating a new merge request thread
 export const CreateMergeRequestThreadSchema = ProjectParamsSchema.extend({
@@ -4006,3 +4023,70 @@ export const ListDependencyProxyBlobsSchema = z.object({
 export const PurgeDependencyProxyCacheSchema = z.object({
     group_id: z.coerce.string().describe("Group ID or URL-encoded path"),
 });
+// --- Vulnerability schemas ---
+// Schema for listing project vulnerabilities with optional filters (GraphQL-backed)
+export const ListProjectVulnerabilitiesSchema = z.object({
+    project_id: z.coerce.string().describe("Project ID or URL-encoded path"),
+    state: z
+        .enum(["detected", "confirmed", "resolved", "dismissed"])
+        .optional()
+        .describe("Filter by vulnerability state"),
+    severity: z
+        .enum(["critical", "high", "medium", "low", "info", "unknown"])
+        .optional()
+        .describe("Filter by severity level"),
+    report_type: z
+        .enum([
+        "sast",
+        "dast",
+        "dependency_scanning",
+        "container_scanning",
+        "secret_detection",
+        "coverage_fuzzing",
+        "api_fuzzing",
+        "cluster_image_scanning",
+        "generic",
+    ])
+        .optional()
+        .describe("Filter by scan/report type (e.g. secret_detection, sast, dast)"),
+    first: z.coerce
+        .number()
+        .int()
+        .min(1)
+        .max(100)
+        .optional()
+        .describe("Number of vulnerabilities to return (max: 100, default: 20)"),
+    after: z
+        .string()
+        .optional()
+        .describe("Cursor for pagination; use the endCursor from a previous response"),
+});
+// Schema for getting a single vulnerability by ID
+export const GetVulnerabilitySchema = z.object({
+    vulnerability_id: z.coerce
+        .string()
+        .describe("The vulnerability ID (numeric or GraphQL global ID)"),
+});
+// Schema for dismissing a vulnerability with required reason and optional comment
+export const DismissVulnerabilitySchema = z.object({
+    vulnerability_id: z.coerce
+        .string()
+        .describe("The ID of the vulnerability to dismiss (numeric or GraphQL global ID)"),
+    reason: z
+        .enum([
+        "acceptable_risk",
+        "false_positive",
+        "used_in_tests",
+        "mitigating_control",
+        "not_applicable",
+    ])
+        .describe("Reason for dismissal"),
+    comment: z.string().optional().describe("Optional comment explaining the dismissal"),
+});
+// Schema for confirming a vulnerability with optional comment
+export const ConfirmVulnerabilitySchema = z.object({
+    vulnerability_id: z.coerce
+        .string()
+        .describe("The ID of the vulnerability to confirm (numeric or GraphQL global ID)"),
+    comment: z.string().optional().describe("Optional comment explaining the confirmation"),
+});

package/build/scripts/check-skill-sync.js

@@ -14,6 +14,7 @@ const SKILL_PATH = join(REPO_ROOT, "skills", "gitlab-mcp", "SKILL.md");
 const REF_DIR = join(REPO_ROOT, "skills", "gitlab-mcp", "reference");
 // Response field names in reference docs — not MCP tools.
 const REFERENCE_FIELD_ALLOWLIST = new Set([
+    "after",
     "allow_multiple",
     "deleted_file",
     "excluded_file_patterns",

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/draft-note-schema.test.js

@@ -0,0 +1,44 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { GitLabDraftNoteSchema } from "../schemas.js";
+test("draft note schema keeps Draft Notes API fields and drops fake timestamps", () => {
+    const parsed = GitLabDraftNoteSchema.parse({
+        id: 42,
+        author_id: 7,
+        note: "looks wrong on this line",
+        line_code: "a1b2c3d4e5f6_12_17",
+        merge_request_id: 99,
+        commit_id: "abc123",
+        discussion_id: null,
+        position: { new_path: "src/app.ts", new_line: 17 },
+        resolve_discussion: false,
+        // Notes-API leftovers that Draft Notes API never returns — must be stripped
+        created_at: "2024-01-01T00:00:00Z",
+        updated_at: "2024-01-02T00:00:00Z",
+    });
+    assert.equal(parsed.id, "42");
+    assert.equal(parsed.author_id, 7);
+    assert.equal(parsed.body, "looks wrong on this line");
+    assert.equal(parsed.line_code, "a1b2c3d4e5f6_12_17");
+    assert.equal(parsed.merge_request_id, 99);
+    assert.equal(parsed.commit_id, "abc123");
+    assert.equal(parsed.discussion_id, null);
+    assert.equal(parsed.resolve_discussion, false);
+    assert.equal("created_at" in parsed, false);
+    assert.equal("updated_at" in parsed, false);
+});
+test("draft note schema preserves null line_code for unresolved positions", () => {
+    const parsed = GitLabDraftNoteSchema.parse({
+        id: "43",
+        author_id: 7,
+        note: "orphan draft",
+        line_code: null,
+        merge_request_id: 99,
+        commit_id: null,
+        discussion_id: null,
+        position: null,
+        resolve_discussion: false,
+    });
+    assert.equal(parsed.line_code, null);
+    assert.equal(parsed.commit_id, null);
+});

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-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");
+    });
+});