@zereight/mcp-gitlab 2.1.28 → 2.1.30

package/build/test/test-mr-file-diffs.js

@@ -115,7 +115,7 @@ describe('list_merge_request_changed_files', () => {
     let mockGitLab;
     let mockGitLabUrl;
     before(async () => {
-        const mockPort = await findMockServerPort(9150);
+        const mockPort = await findMockServerPort();
         mockGitLab = new MockGitLabServer({
             port: mockPort,
             validTokens: [MOCK_TOKEN]
@@ -177,7 +177,7 @@ describe('get_merge_request_file_diff', () => {
     let mockGitLab;
     let mockGitLabUrl;
     before(async () => {
-        const mockPort = await findMockServerPort(9200);
+        const mockPort = await findMockServerPort();
         mockGitLab = new MockGitLabServer({
             port: mockPort,
             validTokens: [MOCK_TOKEN]

package/build/test/test-oauth-proxy-rate-limit.js

@@ -38,7 +38,7 @@ describe("When MCP OAuth runs behind a trusted proxy", () => {
         let mockGitLab;
         let servers = [];
         before(async () => {
-            const mockPort = await findMockServerPort(MOCK_GITLAB_PORT_BASE);
+            const mockPort = await findMockServerPort();
             mockGitLab = new MockGitLabServer({ port: mockPort, validTokens: [] });
             await mockGitLab.start();
             const mockGitLabUrl = mockGitLab.getUrl();

package/build/test/test-permission-mode.js

@@ -0,0 +1,215 @@
+/**
+ * Permission Mode Test Suite
+ *
+ * Tests GITLAB_PERMISSION_MODE (readonly / modify / full), its interaction with
+ * the legacy GITLAB_READ_ONLY_MODE flag, and enforcement at list_tools,
+ * call_tool, and execute_graphql levels.
+ */
+import { describe, test, after, before } from "node:test";
+import assert from "node:assert";
+import { launchServer, findAvailablePort, cleanupServers, TransportMode, HOST, } 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-permission-mode-test";
+const MOCK_PORT_BASE = 9700;
+const MCP_PORT_BASE = 3700;
+let mockGitLab;
+let mockGitLabUrl;
+let portCounter = 0;
+async function nextMcpPort() {
+    return findAvailablePort(MCP_PORT_BASE + portCounter++ * 10);
+}
+async function launchMcpServer(extraEnv = {}) {
+    const port = await nextMcpPort();
+    return launchServer({
+        mode: TransportMode.STREAMABLE_HTTP,
+        port,
+        timeout: 10000,
+        env: {
+            STREAMABLE_HTTP: "true",
+            REMOTE_AUTHORIZATION: "true",
+            GITLAB_API_URL: `${mockGitLabUrl}/api/v4`,
+            GITLAB_TOOLSETS: "all",
+            ...extraEnv,
+        },
+    });
+}
+function mcpUrl(server) {
+    return `http://${HOST}:${server.port}/mcp`;
+}
+async function connectClient(server) {
+    const client = new CustomHeaderClient({
+        authorization: `Bearer ${MOCK_TOKEN}`,
+    });
+    await client.connect(mcpUrl(server));
+    return client;
+}
+async function getToolNames(server) {
+    const client = await connectClient(server);
+    const result = await client.listTools();
+    await client.disconnect();
+    return result.tools.map((t) => t.name);
+}
+const DELETE_SAMPLE_TOOLS = [
+    "delete_issue",
+    "delete_branch",
+    "delete_label",
+    "delete_wiki_page",
+    "delete_milestone",
+    "delete_project_variable",
+];
+const MODIFY_SAMPLE_TOOLS = [
+    "create_issue",
+    "update_issue",
+    "create_merge_request",
+    "create_branch",
+    "push_files",
+    "merge_merge_request",
+];
+const READ_SAMPLE_TOOLS = ["list_issues", "get_project", "list_merge_requests"];
+describe("Permission Mode", { concurrency: 1 }, () => {
+    before(async () => {
+        const mockPort = await findMockServerPort();
+        mockGitLab = new MockGitLabServer({
+            port: mockPort,
+            validTokens: [MOCK_TOKEN],
+        });
+        await mockGitLab.start();
+        mockGitLabUrl = mockGitLab.getUrl();
+    });
+    after(async () => {
+        if (mockGitLab)
+            await mockGitLab.stop();
+    });
+    describe("full mode (default)", () => {
+        let server;
+        const servers = [];
+        before(async () => {
+            server = await launchMcpServer();
+            servers.push(server);
+        });
+        after(() => cleanupServers(servers));
+        test("exposes read, modify, and delete tools", async () => {
+            const names = await getToolNames(server);
+            for (const name of [...READ_SAMPLE_TOOLS, ...MODIFY_SAMPLE_TOOLS, ...DELETE_SAMPLE_TOOLS]) {
+                assert.ok(names.includes(name), `full mode: expected "${name}" to be present`);
+            }
+        });
+    });
+    describe("modify mode", () => {
+        let server;
+        const servers = [];
+        before(async () => {
+            server = await launchMcpServer({ GITLAB_PERMISSION_MODE: "modify" });
+            servers.push(server);
+        });
+        after(() => cleanupServers(servers));
+        test("hides delete tools but keeps read and modify tools", async () => {
+            const names = await getToolNames(server);
+            for (const name of DELETE_SAMPLE_TOOLS) {
+                assert.ok(!names.includes(name), `modify mode: expected "${name}" to be absent`);
+            }
+            for (const name of [...READ_SAMPLE_TOOLS, ...MODIFY_SAMPLE_TOOLS]) {
+                assert.ok(names.includes(name), `modify mode: expected "${name}" to be present`);
+            }
+            assert.ok(!names.some(n => n.startsWith("delete_")), "no delete_* tool should be listed");
+        });
+        test("hides purge_dependency_proxy_cache", async () => {
+            const names = await getToolNames(server);
+            assert.ok(!names.includes("purge_dependency_proxy_cache"), "modify mode: purge_dependency_proxy_cache should be absent");
+        });
+        test("rejects direct delete tool calls", async () => {
+            const client = await connectClient(server);
+            try {
+                await assert.rejects(() => client.callTool("delete_issue", { project_id: "1", issue_iid: 1 }), (error) => error.message.includes("not allowed in modify mode"), "delete_issue should be rejected in modify mode");
+                await assert.rejects(() => client.callTool("purge_dependency_proxy_cache", { group_id: "my-group" }), (error) => error.message.includes("not allowed in modify mode"), "purge_dependency_proxy_cache should be rejected in modify mode");
+            }
+            finally {
+                await client.disconnect();
+            }
+        });
+        test("rejects delete mutations via execute_graphql", async () => {
+            const client = await connectClient(server);
+            try {
+                await assert.rejects(() => client.callTool("execute_graphql", {
+                    query: 'mutation { issueDelete(input: { projectPath: "g/p", iid: "1" }) { errors } }',
+                }), (error) => error.message.includes("delete mutations in modify mode"), "delete mutation should be rejected in modify mode");
+            }
+            finally {
+                await client.disconnect();
+            }
+        });
+        test("does not apply the modify-mode guard to non-delete mutations", async () => {
+            const client = await connectClient(server);
+            try {
+                // The mock GitLab server has no GraphQL endpoint, so the call may fail
+                // downstream — but it must not fail with the modify-mode guard error.
+                await client.callTool("execute_graphql", {
+                    query: "mutation { issueSetSeverity(input: { severity: HIGH }) { errors } }",
+                });
+            }
+            catch (error) {
+                assert.ok(error instanceof Error);
+                assert.ok(!error.message.includes("modify mode"), `non-delete mutation should pass the guard, got: ${error.message}`);
+            }
+            finally {
+                await client.disconnect();
+            }
+        });
+    });
+    describe("readonly mode via GITLAB_PERMISSION_MODE", () => {
+        let server;
+        const servers = [];
+        before(async () => {
+            server = await launchMcpServer({ GITLAB_PERMISSION_MODE: "readonly" });
+            servers.push(server);
+        });
+        after(() => cleanupServers(servers));
+        test("exposes only read-only tools", async () => {
+            const names = await getToolNames(server);
+            for (const name of READ_SAMPLE_TOOLS) {
+                assert.ok(names.includes(name), `readonly mode: expected "${name}" to be present`);
+            }
+            for (const name of [...MODIFY_SAMPLE_TOOLS, ...DELETE_SAMPLE_TOOLS]) {
+                assert.ok(!names.includes(name), `readonly mode: expected "${name}" to be absent`);
+            }
+        });
+        test("rejects write tool calls", async () => {
+            const client = await connectClient(server);
+            try {
+                await assert.rejects(() => client.callTool("create_issue", { project_id: "1", title: "t" }), (error) => error.message.includes("not allowed in read-only mode"), "create_issue should be rejected in readonly mode");
+            }
+            finally {
+                await client.disconnect();
+            }
+        });
+    });
+    describe("legacy GITLAB_READ_ONLY_MODE interaction", () => {
+        const servers = [];
+        after(() => cleanupServers(servers));
+        test("GITLAB_READ_ONLY_MODE=true still behaves as readonly", async () => {
+            const server = await launchMcpServer({ GITLAB_READ_ONLY_MODE: "true" });
+            servers.push(server);
+            const names = await getToolNames(server);
+            assert.ok(names.includes("list_issues"), "read tool should be present");
+            assert.ok(!names.includes("create_issue"), "write tool should be absent");
+            assert.ok(!names.includes("delete_issue"), "delete tool should be absent");
+        });
+        test("GITLAB_READ_ONLY_MODE=true wins over GITLAB_PERMISSION_MODE=full", async () => {
+            const server = await launchMcpServer({
+                GITLAB_READ_ONLY_MODE: "true",
+                GITLAB_PERMISSION_MODE: "full",
+            });
+            servers.push(server);
+            const names = await getToolNames(server);
+            assert.ok(!names.includes("create_issue"), "legacy readonly should take precedence");
+            assert.ok(!names.includes("delete_issue"), "legacy readonly should take precedence");
+        });
+        test("rejects invalid GITLAB_PERMISSION_MODE even when GITLAB_READ_ONLY_MODE=true", async () => {
+            await assert.rejects(launchMcpServer({
+                GITLAB_READ_ONLY_MODE: "true",
+                GITLAB_PERMISSION_MODE: "write",
+            }), (error) => error.message.includes("Server process exited with code 1"), "invalid permission mode should fail startup before legacy override applies");
+        });
+    });
+});

package/build/test/test-protected-branches.js

@@ -71,7 +71,7 @@ describe("protected branch tools", () => {
     let mockGitLab;
     let mockGitLabUrl;
     before(async () => {
-        const mockPort = await findMockServerPort(20500, 50);
+        const mockPort = await findMockServerPort();
         mockGitLab = new MockGitLabServer({
             port: mockPort,
             validTokens: [MOCK_TOKEN],

package/build/test/test-remote-downloads.js

@@ -49,7 +49,7 @@ describe('Remote Downloads - Download Proxy Endpoint', { timeout: 30_000 }, () =
     let server;
     let serverPort;
     before(async () => {
-        const mockPort = await findMockServerPort(9300);
+        const mockPort = await findMockServerPort();
         mockGitLab = new MockGitLabServer({
             port: mockPort,
             validTokens: [MOCK_TOKEN, LARGE_FILE_TOKEN],
@@ -222,7 +222,7 @@ describe('Remote Downloads - Tool Behavior via MCP Protocol', { timeout: 60_000
     let serverPort;
     let sessionId;
     before(async () => {
-        const mockPort = await findMockServerPort(9310);
+        const mockPort = await findMockServerPort();
         mockGitLab = new MockGitLabServer({
             port: mockPort,
             validTokens: [MOCK_TOKEN],

package/build/test/test-search-code.js

@@ -58,7 +58,7 @@ let mockGitLab;
 let mockGitLabUrl;
 describe("Search Code Tools", () => {
     before(async () => {
-        const mockPort = await findMockServerPort(MOCK_PORT_BASE);
+        const mockPort = await findMockServerPort();
         mockGitLab = new MockGitLabServer({
             port: mockPort,
             validTokens: [MOCK_TOKEN],

package/build/test/test-tags.js

@@ -88,7 +88,7 @@ describe("tag tools", () => {
     let mockGitLab;
     let mockGitLabUrl;
     before(async () => {
-        const mockPort = await findMockServerPort(20000, 50);
+        const mockPort = await findMockServerPort();
         mockGitLab = new MockGitLabServer({
             port: mockPort,
             validTokens: [MOCK_TOKEN],

package/build/test/test-todos.js

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

package/build/test/test-token-optimizations.js

@@ -129,7 +129,7 @@ describe("Tool Policy (Proposal F)", { concurrency: 1 }, () => {
     let mockGitLab;
     let mockGitLabUrl;
     before(async () => {
-        const mockPort = await findMockServerPort(MOCK_PORT_BASE);
+        const mockPort = await findMockServerPort();
         mockGitLab = new MockGitLabServer({
             port: mockPort,
             validTokens: [MOCK_TOKEN],
@@ -277,7 +277,7 @@ describe("Policy Edge Cases", { concurrency: 1 }, () => {
     let mockGitLab;
     let mockGitLabUrl;
     before(async () => {
-        const mockPort = await findMockServerPort(MOCK_PORT_BASE + 50);
+        const mockPort = await findMockServerPort();
         mockGitLab = new MockGitLabServer({
             port: mockPort,
             validTokens: [MOCK_TOKEN],
@@ -557,7 +557,7 @@ describe("Dynamic Discovery (Proposal H)", { concurrency: 1 }, () => {
     let mockGitLab;
     let mockGitLabUrl;
     before(async () => {
-        const mockPort = await findMockServerPort(MOCK_PORT_BASE + 100);
+        const mockPort = await findMockServerPort();
         mockGitLab = new MockGitLabServer({
             port: mockPort,
             validTokens: [MOCK_TOKEN],

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

@@ -128,7 +128,7 @@ async function nextMcpPort() {
 }
 describe("Toolset Filtering", { concurrency: 1 }, () => {
     before(async () => {
-        const mockPort = await findMockServerPort(MOCK_PORT_BASE);
+        const mockPort = await findMockServerPort();
         mockGitLab = new MockGitLabServer({
             port: mockPort,
             validTokens: [MOCK_TOKEN],

package/build/test/test-update-issue-slim.js

@@ -0,0 +1,141 @@
+/**
+ * Tests for the update_issue slim response (issue #563).
+ * By default update_issue returns a slim confirmation; full_response=true
+ * returns the complete updated issue object.
+ */
+import { describe, test, before, after } from "node:test";
+import assert from "node:assert";
+import { launchServer, findAvailablePort, cleanupServers, TransportMode, HOST, } 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-slim-update-test-token";
+describe("update_issue slim response", () => {
+    let mockGitLab;
+    let server;
+    let client;
+    const MOCK_PORT_BASE = 9650;
+    const MCP_PORT_BASE = 3650;
+    before(async () => {
+        const mockPort = await findMockServerPort();
+        mockGitLab = new MockGitLabServer({
+            port: mockPort,
+            validTokens: [MOCK_TOKEN],
+        });
+        await mockGitLab.start();
+        server = await launchServer({
+            mode: TransportMode.STREAMABLE_HTTP,
+            port: await findAvailablePort(MCP_PORT_BASE),
+            timeout: 10000,
+            env: {
+                STREAMABLE_HTTP: "true",
+                REMOTE_AUTHORIZATION: "true",
+                GITLAB_API_URL: `${mockGitLab.getUrl()}/api/v4`,
+                GITLAB_ACCESS_TOKEN: MOCK_TOKEN,
+                GITLAB_TOOLSETS: "issues",
+            },
+        });
+        client = new CustomHeaderClient({
+            headers: {
+                authorization: `Bearer ${MOCK_TOKEN}`,
+            },
+        });
+        await client.connect(`http://${HOST}:${server.port ?? 0}/mcp`);
+    });
+    after(async () => {
+        await client?.disconnect();
+        cleanupServers([server]);
+        await mockGitLab?.stop();
+    });
+    test("default response is slim: no description echo", async () => {
+        const result = await client.callTool("update_issue", {
+            project_id: "test/project",
+            issue_iid: "1",
+            description: "A very long description that should not be echoed back",
+        });
+        const data = JSON.parse(result.content[0]?.text || "{}");
+        assert.strictEqual(data.iid, "1");
+        assert.strictEqual(data.state, "opened");
+        assert.ok(data.title, "title should be present");
+        assert.ok(data.web_url, "web_url should be present");
+        assert.ok(data.updated_at, "updated_at should be present");
+        assert.strictEqual(data.description, undefined, "description must not be echoed");
+        assert.strictEqual(data.author, undefined, "author must not be included");
+        assert.strictEqual(data.milestone, undefined, "milestone must not be included");
+    });
+    test("slim response reflects state changes", async () => {
+        const result = await client.callTool("update_issue", {
+            project_id: "test/project",
+            issue_iid: "2",
+            state_event: "close",
+        });
+        const data = JSON.parse(result.content[0]?.text || "{}");
+        assert.strictEqual(data.state, "closed");
+        assert.strictEqual(data.description, undefined);
+    });
+    test('full_response="false" string keeps the response slim', async () => {
+        const result = await client.callTool("update_issue", {
+            project_id: "test/project",
+            issue_iid: "3",
+            description: "A long description that should still not be echoed",
+            full_response: "false",
+        });
+        const data = JSON.parse(result.content[0]?.text || "{}");
+        assert.strictEqual(data.description, undefined);
+        assert.strictEqual(data.author, undefined);
+        assert.strictEqual(data.iid, "3");
+    });
+    test("full_response=true returns the complete issue object", async () => {
+        const result = await client.callTool("update_issue", {
+            project_id: "test/project",
+            issue_iid: "4",
+            description: "Full description expected in response",
+            full_response: true,
+        });
+        const data = JSON.parse(result.content[0]?.text || "{}");
+        assert.strictEqual(data.description, "Full description expected in response");
+        assert.ok(data.author, "author should be present in full response");
+        assert.strictEqual(data.iid, "4");
+    });
+    test("full_response is not forwarded to the GitLab API", async () => {
+        const result = await client.callTool("update_issue", {
+            project_id: "test/project",
+            issue_iid: "5",
+            title: "Updated title",
+            full_response: true,
+        });
+        const data = JSON.parse(result.content[0]?.text || "{}");
+        assert.strictEqual(data.title, "Updated title");
+        assert.strictEqual(data.full_response, undefined, "full_response must not leak into the issue");
+    });
+    test("get_issue slims the milestone by default", async () => {
+        const result = await client.callTool("get_issue", {
+            project_id: "test/project",
+            issue_iid: "100",
+        });
+        const data = JSON.parse(result.content[0]?.text || "{}");
+        assert.ok(data.milestone, "milestone should be present");
+        assert.strictEqual(data.milestone.title, "Sprint 42");
+        assert.ok(data.milestone.web_url, "milestone web_url should be present");
+        assert.strictEqual(data.milestone.description, undefined, "milestone description must not be echoed by default");
+        assert.ok(data.description, "issue description should still be present");
+    });
+    test("get_issue full_response=true returns the full milestone", async () => {
+        const result = await client.callTool("get_issue", {
+            project_id: "test/project",
+            issue_iid: "100",
+            full_response: true,
+        });
+        const data = JSON.parse(result.content[0]?.text || "{}");
+        assert.ok(data.milestone, "milestone should be present");
+        assert.ok(typeof data.milestone.description === "string" && data.milestone.description.length > 0, "milestone description should be included with full_response");
+    });
+    test("get_issue without milestone is unaffected", async () => {
+        const result = await client.callTool("get_issue", {
+            project_id: "test/project",
+            issue_iid: "6",
+        });
+        const data = JSON.parse(result.content[0]?.text || "{}");
+        assert.strictEqual(data.milestone, null);
+        assert.strictEqual(data.iid, "6");
+    });
+});

package/build/test/test-upload-markdown.js

@@ -68,7 +68,7 @@ describe('upload_markdown', () => {
         lastRawBody = undefined;
     });
     before(async () => {
-        const port = await findMockServerPort(9200);
+        const port = await findMockServerPort();
         mockGitLab = new MockGitLabServer({ port, validTokens: [MOCK_TOKEN] });
         await mockGitLab.start();
         env = {

package/build/test/utils/download-token.test.js

@@ -0,0 +1,35 @@
+import { describe, test } from "node:test";
+import assert from "node:assert";
+import { createDownloadToken, decryptDownloadToken } from "../../utils/download-token.js";
+describe("download token helpers", () => {
+    test("round-trips auth, api URL, and resource binding", () => {
+        const token = createDownloadToken("Authorization", "Bearer glpat-example-token", "https://gitlab.example.com/api/v4", {
+            type: "attachment",
+            params: { project_id: "group/project", secret: "abc", filename: "file.txt" },
+        });
+        const decrypted = decryptDownloadToken(token);
+        assert.deepStrictEqual(decrypted, {
+            header: "Authorization",
+            token: "Bearer glpat-example-token",
+            apiUrl: "https://gitlab.example.com/api/v4",
+            resourceType: "attachment",
+            resourceParams: { project_id: "group/project", secret: "abc", filename: "file.txt" },
+        });
+    });
+    test("returns null for invalid tokens", () => {
+        assert.strictEqual(decryptDownloadToken("not-a-valid-token"), null);
+    });
+    test("returns null for expired tokens", () => {
+        const originalNow = Date.now;
+        const issuedAt = 1_700_000_000_000;
+        try {
+            Date.now = () => issuedAt;
+            const token = createDownloadToken("Private-Token", "glpat-example-token");
+            Date.now = () => issuedAt + 301_000;
+            assert.strictEqual(decryptDownloadToken(token), null);
+        }
+        finally {
+            Date.now = originalNow;
+        }
+    });
+});

package/build/test/utils/forwarded-public-base-url.test.js

@@ -1,6 +1,6 @@
 import { describe, test } from "node:test";
 import assert from "node:assert";
-import { getForwardedPublicBaseUrl } from "../../utils/forwarded-public-base-url.js";
+import { getForwardedPublicBaseUrl, getForwardedRequestHost } from "../../utils/forwarded-public-base-url.js";
 function req(headers) {
     return { headers };
 }
@@ -36,3 +36,11 @@ describe("getForwardedPublicBaseUrl", () => {
         }), true), "https://mcp.example.com");
     });
 });
+describe("getForwardedRequestHost", () => {
+    test("returns undefined unless proxy headers are trusted", () => {
+        assert.strictEqual(getForwardedRequestHost(req({ "x-forwarded-host": "mcp.example.com" }), false), undefined);
+    });
+    test("returns the forwarded host when proxy headers are trusted", () => {
+        assert.strictEqual(getForwardedRequestHost(req({ "x-forwarded-host": "mcp.example.com" }), true), "mcp.example.com");
+    });
+});

package/build/test/utils/graphql-query.test.js

@@ -1,6 +1,6 @@
 import assert from "node:assert/strict";
 import { describe, test } from "node:test";
-import { graphqlQueryContainsWriteOperation } from "../../utils/graphql-query.js";
+import { graphqlQueryContainsWriteOperation, graphqlQueryContainsDeleteOperation, } from "../../utils/graphql-query.js";
 describe("When graphqlQueryContainsWriteOperation runs", () => {
     describe("with read-only GraphQL documents", () => {
         test("should allow explicit query operations", () => {
@@ -15,6 +15,18 @@ describe("When graphqlQueryContainsWriteOperation runs", () => {
         test("should ignore mutation text inside string literals", () => {
             assert.equal(graphqlQueryContainsWriteOperation('query { search(query: "mutation") { nodes { id } } }'), false);
         });
+        test("should ignore escaped triple quotes inside block strings", () => {
+            assert.equal(graphqlQueryContainsWriteOperation('query { project(fullPath: """contains \\""" not a mutation""") { id } }'), false);
+        });
+        test("should not treat subscription field names as write operations", () => {
+            assert.equal(graphqlQueryContainsWriteOperation("query { project { id }, subscription { count } }"), false);
+        });
+        test("should allow query with operation name 'mutation'", () => {
+            assert.equal(graphqlQueryContainsWriteOperation("query mutation { project { id } }"), false);
+        });
+        test("should allow query with operation name 'subscription'", () => {
+            assert.equal(graphqlQueryContainsWriteOperation("query subscription { project { id } }"), false);
+        });
     });
     describe("with write GraphQL documents", () => {
         test("should detect mutation operations", () => {
@@ -29,5 +41,56 @@ describe("When graphqlQueryContainsWriteOperation runs", () => {
         test("should detect semicolon-separated write operations", () => {
             assert.equal(graphqlQueryContainsWriteOperation("query A { a }; mutation B { b }"), true);
         });
+        test("should detect comma-prefixed write operations", () => {
+            assert.equal(graphqlQueryContainsWriteOperation(",mutation { destroyProject(input: { projectId: 1 }) { errors } }"), true);
+        });
+        test("should detect comma-separated write operations", () => {
+            assert.equal(graphqlQueryContainsWriteOperation("query A { a }, mutation B { b }"), true);
+        });
+    });
+});
+describe("When graphqlQueryContainsDeleteOperation runs", () => {
+    describe("with non-delete documents", () => {
+        test("should allow plain queries even when they mention delete words", () => {
+            assert.equal(graphqlQueryContainsDeleteOperation("query { project { removeSourceBranchAfterMerge } }"), false);
+        });
+        test("should allow non-delete mutations", () => {
+            assert.equal(graphqlQueryContainsDeleteOperation('mutation { issueSetSeverity(input: { severity: HIGH }) { errors } }'), false);
+        });
+        test("should not count delete-like argument names inside parentheses", () => {
+            assert.equal(graphqlQueryContainsDeleteOperation("mutation { mergeRequestUpdate(input: { removeSourceBranch: true }) { errors } }"), false);
+        });
+        test("should not count delete-like fields nested below the mutation root", () => {
+            assert.equal(graphqlQueryContainsDeleteOperation("mutation { issueSetLabels(input: {}) { issue { canBeDeleted } } }"), false);
+        });
+        test("should ignore delete text inside comments", () => {
+            assert.equal(graphqlQueryContainsDeleteOperation("# issueDelete\nmutation { issueSetLabels { errors } }"), false);
+        });
+        test("should ignore delete text inside string literals", () => {
+            assert.equal(graphqlQueryContainsDeleteOperation('mutation { createNote(input: { body: "projectDelete" }) { errors } }'), false);
+        });
+    });
+    describe("with delete documents", () => {
+        test("should detect delete mutation fields", () => {
+            assert.equal(graphqlQueryContainsDeleteOperation('mutation { issueDelete(input: { projectPath: "g/p", iid: "1" }) { errors } }'), true);
+        });
+        test("should detect destroy mutation fields", () => {
+            assert.equal(graphqlQueryContainsDeleteOperation('mutation { destroyBoard(input: { id: "gid://gitlab/Board/1" }) { errors } }'), true);
+        });
+        test("should detect remove mutation fields", () => {
+            assert.equal(graphqlQueryContainsDeleteOperation("mutation { awardEmojiRemove(input: {}) { errors } }"), true);
+        });
+        test("should detect aliased delete mutation fields", () => {
+            assert.equal(graphqlQueryContainsDeleteOperation("mutation { a: issueDelete(input: {}) { errors } }"), true);
+        });
+        test("should detect delete mutations in multi-operation documents", () => {
+            assert.equal(graphqlQueryContainsDeleteOperation("query A { project { id } } mutation B { labelDelete(input: {}) { errors } }"), true);
+        });
+        test("should detect delete mutations with variable definitions", () => {
+            assert.equal(graphqlQueryContainsDeleteOperation("mutation DeleteIssue($id: IssueID!) { issueDelete(input: { id: $id }) { errors } }"), true);
+        });
+        test("should conservatively block top-level fragment spreads in mutations", () => {
+            assert.equal(graphqlQueryContainsDeleteOperation("mutation { ...f } fragment f on Mutation { issueDelete(input: {}) { errors } }"), true);
+        });
     });
 });