@zereight/mcp-gitlab 2.1.11 → 2.1.13

package/build/test/test-geteffectiveprojectid.js

@@ -6,7 +6,7 @@ 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 { StreamableHTTPTestClient } from './clients/streamable-http-client.js';
+import { CustomHeaderClient } from './clients/custom-header-client.js';
 // Use the same token that will be passed via GITLAB_TOKEN_TEST environment variable
 const MOCK_TOKEN = process.env.GITLAB_TOKEN_TEST || 'glpat-mock-token-12345';
 const DEFAULT_PROJECT_ID = '123';
@@ -43,6 +43,7 @@ describe('getEffectiveProjectId', { concurrency: 1 }, () => {
                 timeout: 5000,
                 env: {
                     STREAMABLE_HTTP: 'true',
+                    REMOTE_AUTHORIZATION: 'true',
                     GITLAB_API_URL: `${mockGitLabUrl}/api/v4`,
                     GITLAB_PROJECT_ID: DEFAULT_PROJECT_ID,
                     GITLAB_READ_ONLY_MODE: 'true',
@@ -50,7 +51,9 @@ describe('getEffectiveProjectId', { concurrency: 1 }, () => {
             });
             servers.push(server);
             mcpUrl = `http://${HOST}:${mcpPort}/mcp`;
-            client = new StreamableHTTPTestClient();
+            client = new CustomHeaderClient({
+                authorization: `Bearer ${MOCK_TOKEN}`,
+            });
             await client.connect(mcpUrl);
             console.log(`Mock GitLab: ${mockGitLabUrl}`);
             console.log(`MCP Server: ${mcpUrl}`);
@@ -113,7 +116,7 @@ describe('getEffectiveProjectId', { concurrency: 1 }, () => {
                 port: mcpPort,
                 timeout: 5000,
                 env: {
-                    STREAMABLE_HTTP: 'true',
+                    REMOTE_AUTHORIZATION: 'true',
                     GITLAB_API_URL: `${mockGitLabUrl}/api/v4`,
                     GITLAB_PROJECT_ID: DEFAULT_PROJECT_ID,
                     GITLAB_ALLOWED_PROJECT_IDS: DEFAULT_PROJECT_ID,
@@ -122,7 +125,9 @@ describe('getEffectiveProjectId', { concurrency: 1 }, () => {
             });
             servers.push(server);
             mcpUrl = `http://${HOST}:${mcpPort}/mcp`;
-            client = new StreamableHTTPTestClient();
+            client = new CustomHeaderClient({
+                authorization: `Bearer ${MOCK_TOKEN}`,
+            });
             await client.connect(mcpUrl);
             console.log(`Mock GitLab: ${mockGitLabUrl}`);
             console.log(`MCP Server: ${mcpUrl}`);
@@ -183,7 +188,7 @@ describe('getEffectiveProjectId', { concurrency: 1 }, () => {
                 port: mcpPort,
                 timeout: 5000,
                 env: {
-                    STREAMABLE_HTTP: 'true',
+                    REMOTE_AUTHORIZATION: 'true',
                     GITLAB_API_URL: `${mockGitLabUrl}/api/v4`,
                     GITLAB_ALLOWED_PROJECT_IDS: `${DEFAULT_PROJECT_ID},${OTHER_PROJECT_ID}`,
                     GITLAB_READ_ONLY_MODE: 'true',
@@ -191,7 +196,9 @@ describe('getEffectiveProjectId', { concurrency: 1 }, () => {
             });
             servers.push(server);
             mcpUrl = `http://${HOST}:${mcpPort}/mcp`;
-            client = new StreamableHTTPTestClient();
+            client = new CustomHeaderClient({
+                authorization: `Bearer ${MOCK_TOKEN}`,
+            });
             await client.connect(mcpUrl);
             console.log(`Mock GitLab: ${mockGitLabUrl}`);
             console.log(`MCP Server: ${mcpUrl}`);
@@ -242,4 +249,221 @@ describe('getEffectiveProjectId', { concurrency: 1 }, () => {
             console.log(`  ✓ Allowed access to second project ${OTHER_PROJECT_ID}`);
         });
     });
+    describe('GITLAB_PROJECT_ID guards repository and group mutators', () => {
+        let mcpUrl;
+        let mockGitLab;
+        let servers = [];
+        let client;
+        before(async () => {
+            const mockPort = await findMockServerPort(9400);
+            mockGitLab = new MockGitLabServer({
+                port: mockPort,
+                validTokens: [MOCK_TOKEN]
+            });
+            await mockGitLab.start();
+            const mockGitLabUrl = mockGitLab.getUrl();
+            const mcpPort = await findAvailablePort(3400);
+            const server = await launchServer({
+                mode: TransportMode.STREAMABLE_HTTP,
+                port: mcpPort,
+                timeout: 5000,
+                env: {
+                    REMOTE_AUTHORIZATION: 'true',
+                    GITLAB_API_URL: `${mockGitLabUrl}/api/v4`,
+                    GITLAB_PROJECT_ID: DEFAULT_PROJECT_ID,
+                }
+            });
+            servers.push(server);
+            mcpUrl = `http://${HOST}:${mcpPort}/mcp`;
+            client = new CustomHeaderClient({
+                authorization: `Bearer ${MOCK_TOKEN}`,
+            });
+            await client.connect(mcpUrl);
+        });
+        after(async () => {
+            if (client)
+                await client.disconnect();
+            cleanupServers(servers);
+            if (mockGitLab)
+                await mockGitLab.stop();
+        });
+        test('should reject create_repository when GITLAB_PROJECT_ID is set', async () => {
+            try {
+                await client.callTool('create_repository', { name: 'test-repo' });
+                assert.fail('Should have rejected create_repository');
+            }
+            catch (error) {
+                assert.ok(error instanceof Error);
+                assert.ok(error.message.includes('create_repository is not allowed'), 'Should mention create_repository');
+            }
+        });
+        test('should reject fork_repository when GITLAB_PROJECT_ID is set', async () => {
+            try {
+                await client.callTool('fork_repository', { project_id: '999' });
+                assert.fail('Should have rejected fork_repository');
+            }
+            catch (error) {
+                assert.ok(error instanceof Error);
+                assert.ok(error.message.includes('fork_repository is not allowed'), 'Should mention fork_repository');
+            }
+        });
+        test('should reject create_group when GITLAB_PROJECT_ID is set', async () => {
+            try {
+                await client.callTool('create_group', { name: 'test-group', path: 'test-group' });
+                assert.fail('Should have rejected create_group');
+            }
+            catch (error) {
+                assert.ok(error instanceof Error);
+                assert.ok(error.message.includes('create_group is not allowed'), 'Should mention create_group');
+            }
+        });
+        test('should allow get_project (non-mutator) when GITLAB_PROJECT_ID is set', async () => {
+            const result = await client.callTool('get_project', { project_id: '' });
+            assert.ok(result.content, 'Should have content');
+            const content = result.content[0];
+            assert.ok('text' in content, 'Content should have text');
+            const project = JSON.parse(content.text);
+            assert.strictEqual(project.id.toString(), DEFAULT_PROJECT_ID, 'Should use default project');
+        });
+    });
+    describe('GITLAB_ALLOWED_PROJECT_IDS guards repository and group mutators (allowlist-only, no GITLAB_PROJECT_ID)', () => {
+        let mcpUrl;
+        let mockGitLab;
+        let servers = [];
+        let client;
+        before(async () => {
+            const mockPort = await findMockServerPort(9600);
+            mockGitLab = new MockGitLabServer({
+                port: mockPort,
+                validTokens: [MOCK_TOKEN]
+            });
+            await mockGitLab.start();
+            const mockGitLabUrl = mockGitLab.getUrl();
+            const mcpPort = await findAvailablePort(3600);
+            const server = await launchServer({
+                mode: TransportMode.STREAMABLE_HTTP,
+                port: mcpPort,
+                timeout: 5000,
+                env: {
+                    REMOTE_AUTHORIZATION: 'true',
+                    GITLAB_API_URL: `${mockGitLabUrl}/api/v4`,
+                    GITLAB_ALLOWED_PROJECT_IDS: DEFAULT_PROJECT_ID,
+                }
+            });
+            servers.push(server);
+            mcpUrl = `http://${HOST}:${mcpPort}/mcp`;
+            client = new CustomHeaderClient({
+                authorization: `Bearer ${MOCK_TOKEN}`,
+            });
+            await client.connect(mcpUrl);
+        });
+        after(async () => {
+            if (client)
+                await client.disconnect();
+            cleanupServers(servers);
+            if (mockGitLab)
+                await mockGitLab.stop();
+        });
+        test('should reject create_repository with GITLAB_ALLOWED_PROJECT_IDS', async () => {
+            try {
+                await client.callTool('create_repository', { name: 'test-repo' });
+                assert.fail('Should have rejected create_repository');
+            }
+            catch (error) {
+                assert.ok(error instanceof Error);
+                assert.ok(error.message.includes('create_repository is not allowed'), 'Should mention create_repository');
+            }
+        });
+        test('should reject fork_repository with GITLAB_ALLOWED_PROJECT_IDS', async () => {
+            try {
+                await client.callTool('fork_repository', { project_id: '999' });
+                assert.fail('Should have rejected fork_repository');
+            }
+            catch (error) {
+                assert.ok(error instanceof Error);
+                assert.ok(error.message.includes('fork_repository is not allowed'), 'Should mention fork_repository');
+            }
+        });
+        test('should reject create_group with GITLAB_ALLOWED_PROJECT_IDS', async () => {
+            try {
+                await client.callTool('create_group', { name: 'test-group', path: 'test-group' });
+                assert.fail('Should have rejected create_group');
+            }
+            catch (error) {
+                assert.ok(error instanceof Error);
+                assert.ok(error.message.includes('create_group is not allowed'), 'Should mention create_group');
+            }
+        });
+        test('should allow get_project (non-mutator) with GITLAB_ALLOWED_PROJECT_IDS', async () => {
+            const result = await client.callTool('get_project', { project_id: '' });
+            assert.ok(result.content, 'Should have content');
+            const content = result.content[0];
+            assert.ok('text' in content, 'Content should have text');
+            const project = JSON.parse(content.text);
+            assert.strictEqual(project.id.toString(), DEFAULT_PROJECT_ID, 'Should use default project');
+        });
+    });
+    describe('GITLAB_READ_ONLY_MODE enforces read-only for all write tools', () => {
+        let mcpUrl;
+        let mockGitLab;
+        let servers = [];
+        let client;
+        before(async () => {
+            const mockPort = await findMockServerPort(9500);
+            mockGitLab = new MockGitLabServer({
+                port: mockPort,
+                validTokens: [MOCK_TOKEN]
+            });
+            await mockGitLab.start();
+            const mockGitLabUrl = mockGitLab.getUrl();
+            const mcpPort = await findAvailablePort(3500);
+            const server = await launchServer({
+                mode: TransportMode.STREAMABLE_HTTP,
+                port: mcpPort,
+                timeout: 5000,
+                env: {
+                    REMOTE_AUTHORIZATION: 'true',
+                    GITLAB_API_URL: `${mockGitLabUrl}/api/v4`,
+                    GITLAB_READ_ONLY_MODE: 'true',
+                }
+            });
+            servers.push(server);
+            mcpUrl = `http://${HOST}:${mcpPort}/mcp`;
+            client = new CustomHeaderClient({
+                authorization: `Bearer ${MOCK_TOKEN}`,
+            });
+            await client.connect(mcpUrl);
+        });
+        after(async () => {
+            if (client)
+                await client.disconnect();
+            cleanupServers(servers);
+            if (mockGitLab)
+                await mockGitLab.stop();
+        });
+        test('should reject create_group in read-only mode (no project ID)', async () => {
+            try {
+                await client.callTool('create_group', { name: 'test-group', path: 'test-group' });
+                assert.fail('Should have rejected create_group in read-only mode');
+            }
+            catch (error) {
+                assert.ok(error instanceof Error);
+                assert.ok(error.message.includes('create_group is not allowed'), 'Should mention create_group');
+            }
+        });
+        test('should reject create_repository in read-only mode', async () => {
+            try {
+                await client.callTool('create_repository', { name: 'test-repo' });
+                assert.fail('Should have rejected create_repository in read-only mode');
+            }
+            catch (error) {
+                assert.ok(error instanceof Error);
+                assert.ok(error.message.includes('create_repository is not allowed'), 'Should mention create_repository');
+            }
+        });
+        test('should allow get_project (read-only) in read-only mode', async () => {
+            const result = await client.callTool('get_project', { project_id: DEFAULT_PROJECT_ID });
+            assert.ok(result.content, 'Should have content');
+        });
+    });
 }); // end wrapper describe

package/build/test/test-issue-description-patch.js

@@ -0,0 +1,256 @@
+/**
+ * Tests for the update_issue_description_patch tool.
+ * Tests search_replace, unified_diff, dry_run, create_note, and edge cases.
+ */
+import { describe, test, before, after } from "node:test";
+import assert from "node:assert";
+import { launchServer, 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";
+import { parseSearchReplaceBlocks, applySearchReplace, applyUnifiedDiff, } from "../utils/patch-helper.js";
+const MOCK_TOKEN = "glpat-patch-test-token-12345";
+// ---- Unit tests for patch helper ----
+describe("parseSearchReplaceBlocks", () => {
+    test("parses a single block", () => {
+        const blocks = parseSearchReplaceBlocks("<<<<<<< SEARCH\nold text\n=======\nnew text\n>>>>>>> REPLACE");
+        assert.strictEqual(blocks.length, 1);
+        assert.strictEqual(blocks[0].search, "old text");
+        assert.strictEqual(blocks[0].replace, "new text");
+    });
+    test("parses multiple blocks", () => {
+        const blocks = parseSearchReplaceBlocks("<<<<<<< SEARCH\nfirst\n=======\nfirst new\n>>>>>>> REPLACE\n<<<<<<< SEARCH\nsecond\n=======\nsecond new\n>>>>>>> REPLACE");
+        assert.strictEqual(blocks.length, 2);
+    });
+    test("handles empty content", () => {
+        const blocks = parseSearchReplaceBlocks("");
+        assert.strictEqual(blocks.length, 0);
+    });
+    test("ignores text outside blocks", () => {
+        const blocks = parseSearchReplaceBlocks("prefix\n<<<<<<< SEARCH\nx\n=======\ny\n>>>>>>> REPLACE\nsuffix");
+        assert.strictEqual(blocks.length, 1);
+    });
+    test("rejects malformed block with missing REPLACE marker", () => {
+        assert.throws(() => parseSearchReplaceBlocks("<<<<<<< SEARCH\nfirst\n=======\nfirst new\n>>>>>>> REPLACE\n" +
+            "<<<<<<< SEARCH\nsecond\n=======\nsecond new\n>>>>>>> TYPO"), /malformed|Marker|marker/);
+    });
+    test("rejects block with missing ======= marker", () => {
+        assert.throws(() => parseSearchReplaceBlocks("<<<<<<< SEARCH\nfoo\n\nbar\n>>>>>>> REPLACE"), /malformed|Marker|marker/);
+    });
+    test("allows prose around valid blocks", () => {
+        const blocks = parseSearchReplaceBlocks("# Some notes\n\n<<<<<<< SEARCH\nfoo\n=======\nbar\n>>>>>>> REPLACE\n\nMore context");
+        assert.strictEqual(blocks.length, 1);
+    });
+});
+describe("applySearchReplace", () => {
+    test("replaces single occurrence", () => {
+        const result = applySearchReplace("Status: In progress\nDone.", [
+            { search: "Status: In progress", replace: "Status: Done" },
+        ]);
+        assert.strictEqual(result.description, "Status: Done\nDone.");
+        assert.strictEqual(result.changes, 1);
+        assert.ok(result.summary.includes("Status: In progress"));
+        assert.ok(result.preview.includes("-Status: In progress"));
+    });
+    test("fails on no match", () => {
+        assert.throws(() => applySearchReplace("Some text.", [{ search: "Nonexistent", replace: "x" }]), /Search text not found/);
+    });
+    test("rejects empty SEARCH body", () => {
+        assert.throws(() => applySearchReplace("Some text.", [{ search: "", replace: "x" }], true), /Empty SEARCH/);
+    });
+    test("fails on duplicate without allowMultiple", () => {
+        assert.throws(() => applySearchReplace("x\ny\nx\n", [{ search: "x", replace: "z" }]), /matches 2 times/);
+    });
+    test("replaces all with allowMultiple", () => {
+        const result = applySearchReplace("x\ny\nx\n", [{ search: "x", replace: "z" }], true);
+        assert.strictEqual(result.changes, 2);
+        assert.strictEqual(result.description, "z\ny\nz\n");
+    });
+    test("fails on identical replacement", () => {
+        assert.throws(() => applySearchReplace("Keep this.", [{ search: "Keep this.", replace: "Keep this." }]), /did not change/);
+    });
+    test("preserves leading blank line in SEARCH block", () => {
+        const source = "\n\nStatus: In progress\n";
+        const result = applySearchReplace(source, [
+            { search: "\n\nStatus: In progress", replace: "\n\nStatus: Done" },
+        ]);
+        assert.strictEqual(result.description, "\n\nStatus: Done\n");
+    });
+    test("preserves leading blank line when patch starts with blank line", () => {
+        const blocks = parseSearchReplaceBlocks("<<<<<<< SEARCH\n\nfoo\n=======\n\nbar\n>>>>>>> REPLACE");
+        assert.strictEqual(blocks.length, 1);
+        assert.strictEqual(blocks[0].search, "\nfoo");
+        assert.strictEqual(blocks[0].replace, "\nbar");
+    });
+    test("replacement with leading blank line works", () => {
+        const result = applySearchReplace("Header\n\nContent\n", [
+            { search: "Content", replace: "\nNewContent" },
+        ]);
+        assert.strictEqual(result.description, "Header\n\n\nNewContent\n");
+    });
+});
+describe("applyUnifiedDiff", () => {
+    test("applies simple diff", () => {
+        const source = "Line 1\nLine 2\nLine 3\n";
+        const patch = "--- old\n+++ new\n@@ -1,3 +1,3 @@\n Line 1\n-Line 2\n+Line 2 modified\n Line 3\n";
+        const result = applyUnifiedDiff(source, patch);
+        assert.ok(result.description.includes("Line 2 modified"));
+    });
+    test("fails on non-matching diff", () => {
+        const source = "AAA\nBBB\n";
+        const patch = "--- old\n+++ new\n@@ -1,2 +1,2 @@\n-XXX\n+YYY\n BBB\n";
+        assert.throws(() => applyUnifiedDiff(source, patch), /could not be applied/);
+    });
+    test("fails on malformed patch", () => {
+        assert.throws(() => applyUnifiedDiff("text", "not a patch"), /no valid hunks/i);
+    });
+});
+// ---- Integration tests via MCP client ----
+describe("update_issue_description_patch MCP tool", () => {
+    let mockGitLab;
+    let server;
+    let client;
+    const MOCK_PORT_BASE = 9600;
+    const MCP_PORT_BASE = 3600;
+    let portCounter = 0;
+    async function launchMcp(mockGitLabUrl, extraEnv = {}) {
+        const port = MCP_PORT_BASE + portCounter++ * 10;
+        return launchServer({
+            mode: TransportMode.STREAMABLE_HTTP,
+            port,
+            timeout: 10000,
+            env: {
+                STREAMABLE_HTTP: "true",
+                REMOTE_AUTHORIZATION: "true",
+                GITLAB_API_URL: `${mockGitLabUrl}/api/v4`,
+                GITLAB_ACCESS_TOKEN: MOCK_TOKEN,
+                ...extraEnv,
+            },
+        });
+    }
+    async function getClient(port) {
+        const client = new CustomHeaderClient({
+            headers: {
+                authorization: `Bearer ${MOCK_TOKEN}`,
+            },
+        });
+        await client.connect(`http://${HOST}:${port}/mcp`);
+        return client;
+    }
+    before(async () => {
+        const mockPort = await findMockServerPort(MOCK_PORT_BASE);
+        mockGitLab = new MockGitLabServer({
+            port: mockPort,
+            validTokens: [MOCK_TOKEN],
+        });
+        await mockGitLab.start();
+        const mockGitLabUrl = mockGitLab.getUrl();
+        server = await launchMcp(mockGitLabUrl, { GITLAB_TOOLSETS: "issues" });
+        client = await getClient(server.port ?? 0);
+    });
+    after(async () => {
+        await client?.disconnect();
+        cleanupServers([server]);
+        await mockGitLab?.stop();
+    });
+    test("tool appears in tool list", async () => {
+        const result = await client.listTools();
+        const names = result.tools.map((t) => t.name);
+        assert.ok(names.includes("update_issue_description_patch"), "tool should be in list");
+    });
+    test("dry_run: search_replace returns preview without modifying", async () => {
+        // Get current description
+        const getResult = await client.callTool("get_issue", {
+            project_id: "test/project",
+            issue_iid: "1",
+        });
+        const issue = JSON.parse(getResult.content[0]?.text || "{}");
+        const originalDesc = issue.description;
+        // Dry-run
+        const result = await client.callTool("update_issue_description_patch", {
+            project_id: "test/project",
+            issue_iid: "1",
+            patch_type: "search_replace",
+            patch: `<<<<<<< SEARCH\n${originalDesc}\n=======\nShould NOT persist\n>>>>>>> REPLACE`,
+            dry_run: true,
+        });
+        const data = JSON.parse(result.content[0]?.text || "{}");
+        assert.strictEqual(data.status, "preview");
+        assert.strictEqual(data.dry_run, true);
+        assert.strictEqual(data.changes, 1);
+        // Verify NOT updated
+        const getAgain = await client.callTool("get_issue", {
+            project_id: "test/project",
+            issue_iid: "1",
+        });
+        const issueAgain = JSON.parse(getAgain.content[0]?.text || "{}");
+        assert.strictEqual(issueAgain.description, originalDesc, "should be unchanged after dry_run");
+    });
+    test("search_replace: applies the patch", async () => {
+        const result = await client.callTool("update_issue_description_patch", {
+            project_id: "test/project",
+            issue_iid: "1",
+            patch_type: "search_replace",
+            patch: `<<<<<<< SEARCH\nDescription for issue 1\n=======\nPatched description\n>>>>>>> REPLACE`,
+        });
+        const data = JSON.parse(result.content[0]?.text || "{}");
+        assert.strictEqual(data.status, "success");
+        assert.strictEqual(data.changes, 1);
+        // Verify persisted
+        const getResult = await client.callTool("get_issue", {
+            project_id: "test/project",
+            issue_iid: "1",
+        });
+        const issue = JSON.parse(getResult.content[0]?.text || "{}");
+        assert.strictEqual(issue.description, "Patched description");
+    });
+    test("create_note: note is attempted after update", async () => {
+        const result = await client.callTool("update_issue_description_patch", {
+            project_id: "test/project",
+            issue_iid: "1",
+            patch_type: "search_replace",
+            patch: `<<<<<<< SEARCH\nPatched description\n=======\nDescription with note\n>>>>>>> REPLACE`,
+            create_note: true,
+        });
+        const data = JSON.parse(result.content[0]?.text || "{}");
+        assert.strictEqual(data.status, "success");
+        assert.ok(data.note !== undefined, "note result should be present");
+    });
+    test("search_replace: fails on no match", async () => {
+        try {
+            await client.callTool("update_issue_description_patch", {
+                project_id: "test/project",
+                issue_iid: "1",
+                patch_type: "search_replace",
+                patch: `<<<<<<< SEARCH\nNonExistentText_{UNIQUE}_\n=======\nShould fail\n>>>>>>> REPLACE`,
+            });
+            assert.fail("Should have thrown");
+        }
+        catch (err) {
+            const msg = err.message ?? String(err);
+            assert.ok(msg.includes("not found"), `Error should mention 'not found': ${msg}`);
+        }
+    });
+    test("unified_diff: applies the patch", async () => {
+        // Set known state
+        await client.callTool("update_issue_description_patch", {
+            project_id: "test/project",
+            issue_iid: "1",
+            patch_type: "search_replace",
+            patch: `<<<<<<< SEARCH\nDescription with note\n=======\nLine 1\nLine 2\nLine 3\n>>>>>>> REPLACE`,
+        });
+        const result = await client.callTool("update_issue_description_patch", {
+            project_id: "test/project",
+            issue_iid: "1",
+            patch_type: "unified_diff",
+            patch: "--- old\n+++ new\n@@ -1,3 +1,3 @@\n Line 1\n-Line 2\n+Line 2 changed\n Line 3\n",
+        });
+        const data = JSON.parse(result.content[0]?.text || "{}");
+        assert.strictEqual(data.status, "success");
+        const getResult = await client.callTool("get_issue", {
+            project_id: "test/project",
+            issue_iid: "1",
+        });
+        const issue = JSON.parse(getResult.content[0]?.text || "{}");
+        assert.ok(issue.description.includes("Line 2 changed"));
+    });
+});

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

@@ -389,7 +389,7 @@ describe("Policy Edge Cases", { concurrency: 1 }, () => {
     test("hiding all toolset tools leaves only discover_tools", async () => {
         const allIssueTools = [
             "create_issue", "list_issues", "my_issues", "get_issue",
-            "update_issue", "delete_issue", "create_issue_note", "update_issue_note",
+            "update_issue", "update_issue_description_patch", "delete_issue", "list_todos", "mark_todo_done", "mark_all_todos_done", "create_issue_note", "update_issue_note",
             "list_issue_links", "list_issue_discussions", "get_issue_link",
             "create_issue_link", "delete_issue_link", "create_note",
             "list_issue_emoji_reactions", "list_issue_note_emoji_reactions",

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

@@ -17,9 +17,9 @@ const MCP_PORT_BASE = 3200;
 // Known tool counts per toolset (from TOOLSET_DEFINITIONS)
 const TOOLSET_TOOL_COUNTS = {
     merge_requests: 41,
-    issues: 23,
+    issues: 24,
     repositories: 7,
-    branches: 6,
+    branches: 10,
     projects: 9,
     labels: 5,
     ci: 2,
@@ -32,6 +32,7 @@ const TOOLSET_TOOL_COUNTS = {
     search: 3,
     workitems: 18,
     webhooks: 3,
+    groups: 1,
 };
 const LEGACY_PIPELINE_TOOL_COUNT = TOOLSET_TOOL_COUNTS.pipelines + TOOLSET_TOOL_COUNTS.ci;
 const DEFAULT_TOOLSETS = [
@@ -43,6 +44,7 @@ const DEFAULT_TOOLSETS = [
     "labels",
     "ci",
     "users",
+    "groups",
 ];
 const NON_DEFAULT_TOOLSETS = [
     "pipelines",
@@ -63,7 +65,7 @@ const TOOLSET_SAMPLE_TOOLS = {
     merge_requests: ["merge_merge_request", "create_merge_request_thread", "list_draft_notes"],
     issues: ["create_issue", "list_issues", "create_note", "list_todos"],
     repositories: ["search_repositories", "get_file_contents", "push_files"],
-    branches: ["create_branch", "list_commits", "list_commit_statuses", "create_commit_status"],
+    branches: ["create_branch", "get_branch", "list_branches", "delete_branch", "list_commits", "list_commit_statuses", "create_commit_status"],
     projects: ["get_project", "list_namespaces", "list_group_iterations"],
     labels: ["list_labels", "create_label"],
     ci: ["validate_ci_lint", "validate_project_ci_lint"],
@@ -75,6 +77,7 @@ const TOOLSET_SAMPLE_TOOLS = {
     users: ["get_users", "upload_markdown", "download_attachment"],
     search: ["search_code", "search_project_code", "search_group_code"],
     webhooks: ["list_webhooks", "list_webhook_events", "get_webhook_event"],
+    groups: ["create_group"],
 };
 // --- Helpers ---
 async function launchMcpServer(mockGitLabUrl, mcpPort, extraEnv = {}) {
@@ -308,6 +311,7 @@ describe("Toolset Filtering", { concurrency: 1 }, () => {
         const writeIssueTools = [
             "create_issue",
             "update_issue",
+            "update_issue_description_patch",
             "delete_issue",
             "mark_todo_done",
             "mark_all_todos_done",

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

@@ -13,6 +13,8 @@ export class MockGitLabServer {
     // Root-level dynamic router (for OAuth paths not under /api/v4)
     rootRouter;
     rootHandlers = new Map();
+    // In-memory store for mutable resources (issues, etc.)
+    issueStore = new Map();
     constructor(config) {
         this.config = config;
         this.app = express();
@@ -314,6 +316,12 @@ export class MockGitLabServer {
         this.app.get("/api/v4/projects/:projectId/issues/:issue_iid", (req, res) => {
             const issueIid = parseInt(req.params.issue_iid);
             const projectId = req.params.projectId;
+            const storeKey = `${projectId}:${issueIid}`;
+            const stored = this.issueStore.get(storeKey);
+            if (stored) {
+                res.json(stored);
+                return;
+            }
             res.json({
                 id: issueIid,
                 iid: issueIid,
@@ -337,6 +345,44 @@ export class MockGitLabServer {
                 milestone: null,
             });
         });
+        // PUT /api/v4/projects/:projectId/issues/:issue_iid - Update issue
+        this.app.put("/api/v4/projects/:projectId/issues/:issue_iid", (req, res) => {
+            const issueIid = parseInt(req.params.issue_iid);
+            const projectId = req.params.projectId;
+            const storeKey = `${projectId}:${issueIid}`;
+            // Build response from stored data (if previously updated) or defaults
+            const stored = this.issueStore.get(storeKey) || {};
+            const description = req.body?.description ?? stored.description ?? `Description for issue ${issueIid}`;
+            const title = req.body?.title ?? stored.title ?? `Test Issue ${issueIid}`;
+            const state = req.body?.state_event === "close" ? "closed" :
+                req.body?.state_event === "reopen" ? "opened" :
+                    (stored.state ?? "opened");
+            const updatedIssue = {
+                id: issueIid,
+                iid: issueIid,
+                project_id: projectId,
+                title,
+                description,
+                state,
+                created_at: stored.created_at ?? "2024-01-01T00:00:00Z",
+                updated_at: new Date().toISOString(),
+                closed_at: state === "closed" ? new Date().toISOString() : null,
+                web_url: `https://gitlab.mock/project/${projectId}/issues/${issueIid}`,
+                author: {
+                    id: 1,
+                    username: "test-user",
+                    name: "Test User",
+                    avatar_url: null,
+                    web_url: "https://gitlab.mock/test-user",
+                },
+                assignees: [],
+                labels: [],
+                milestone: null,
+            };
+            // Store for subsequent GET requests
+            this.issueStore.set(storeKey, updatedIssue);
+            res.json(updatedIssue);
+        });
         // Mock blob search result
         const mockBlobResults = [
             {