@zereight/mcp-gitlab 2.0.34 → 2.0.35

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

@@ -0,0 +1,251 @@
+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 = '123';
+const TEST_MR_IID = '1';
+// Helper to call list_merge_request_changed_files
+async function callListMergeRequestChangedFiles(args = {}, env) {
+    return new Promise((resolve, reject) => {
+        const proc = spawn('node', ['build/index.js'], {
+            stdio: ['pipe', 'pipe', 'pipe'],
+            env: {
+                ...process.env,
+                ...env,
+                GITLAB_READ_ONLY_MODE: '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}`));
+            // Find the JSON line in stdout
+            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 {
+                    // Parse the tool result content
+                    const content = response.result?.content?.[0]?.text;
+                    if (content) {
+                        try {
+                            resolve(JSON.parse(content));
+                        }
+                        catch (e) {
+                            reject(new Error(`Failed to parse tool output JSON: ${content}`));
+                        }
+                    }
+                    else {
+                        resolve(response.result);
+                    }
+                }
+            }
+            catch (e) {
+                reject(e);
+            }
+        });
+        proc.stdin?.end(JSON.stringify({
+            jsonrpc: "2.0", id: 1, method: "tools/call",
+            params: { name: "list_merge_request_changed_files", arguments: args }
+        }) + '\n');
+    });
+}
+// Helper to call get_merge_request_file_diff
+async function callGetMergeRequestFileDiff(args = {}, env) {
+    return new Promise((resolve, reject) => {
+        const proc = spawn('node', ['build/index.js'], {
+            stdio: ['pipe', 'pipe', 'pipe'],
+            env: {
+                ...process.env,
+                ...env,
+                GITLAB_READ_ONLY_MODE: '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}`));
+            // Find the JSON line in stdout
+            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 {
+                    // Parse the tool result content
+                    const content = response.result?.content?.[0]?.text;
+                    if (content) {
+                        try {
+                            resolve(JSON.parse(content));
+                        }
+                        catch (e) {
+                            reject(new Error(`Failed to parse tool output JSON: ${content}`));
+                        }
+                    }
+                    else {
+                        resolve(response.result);
+                    }
+                }
+            }
+            catch (e) {
+                reject(e);
+            }
+        });
+        proc.stdin?.end(JSON.stringify({
+            jsonrpc: "2.0", id: 1, method: "tools/call",
+            params: { name: "get_merge_request_file_diff", arguments: args }
+        }) + '\n');
+    });
+}
+describe('list_merge_request_changed_files', () => {
+    let mockGitLab;
+    let mockGitLabUrl;
+    before(async () => {
+        const mockPort = await findMockServerPort(9150);
+        mockGitLab = new MockGitLabServer({
+            port: mockPort,
+            validTokens: [MOCK_TOKEN]
+        });
+        await mockGitLab.start();
+        mockGitLabUrl = mockGitLab.getUrl();
+    });
+    after(async () => {
+        await mockGitLab.stop();
+    });
+    test('returns all changed files without filtering', async () => {
+        const files = await callListMergeRequestChangedFiles({ project_id: TEST_PROJECT_ID, merge_request_iid: TEST_MR_IID }, {
+            GITLAB_API_URL: `${mockGitLabUrl}/api/v4`,
+            GITLAB_PERSONAL_ACCESS_TOKEN: MOCK_TOKEN
+        });
+        assert.ok(Array.isArray(files), 'Response should be an array');
+        assert.strictEqual(files.length, 4, 'Should return 4 files');
+        // Check structure of returned files
+        for (const file of files) {
+            assert.ok(file.new_path !== undefined, 'Each file should have new_path');
+            assert.ok(file.old_path !== undefined, 'Each file should have old_path');
+        }
+        assert.strictEqual(files[0].new_path, 'src/index.ts');
+        assert.strictEqual(files[1].new_path, 'vendor/package/file.js');
+        assert.strictEqual(files[2].new_path, 'README.md');
+        assert.strictEqual(files[3].new_path, 'package-lock.json');
+    });
+    test('filters out vendor folder with ^vendor/ pattern', async () => {
+        const files = await callListMergeRequestChangedFiles({
+            project_id: TEST_PROJECT_ID,
+            merge_request_iid: TEST_MR_IID,
+            excluded_file_patterns: ['^vendor/']
+        }, {
+            GITLAB_API_URL: `${mockGitLabUrl}/api/v4`,
+            GITLAB_PERSONAL_ACCESS_TOKEN: MOCK_TOKEN
+        });
+        assert.ok(Array.isArray(files), 'Response should be an array');
+        assert.strictEqual(files.length, 3, 'Should return 3 files (vendor filtered out)');
+        assert.strictEqual(files[0].new_path, 'src/index.ts');
+        assert.strictEqual(files[1].new_path, 'README.md');
+        assert.strictEqual(files[2].new_path, 'package-lock.json');
+    });
+    test('filters multiple patterns at once', async () => {
+        const files = await callListMergeRequestChangedFiles({
+            project_id: TEST_PROJECT_ID,
+            merge_request_iid: TEST_MR_IID,
+            excluded_file_patterns: ['^vendor/', 'package-lock\\.json']
+        }, {
+            GITLAB_API_URL: `${mockGitLabUrl}/api/v4`,
+            GITLAB_PERSONAL_ACCESS_TOKEN: MOCK_TOKEN
+        });
+        assert.ok(Array.isArray(files), 'Response should be an array');
+        assert.strictEqual(files.length, 2, 'Should return 2 files (vendor and package-lock filtered out)');
+        assert.strictEqual(files[0].new_path, 'src/index.ts');
+        assert.strictEqual(files[1].new_path, 'README.md');
+    });
+});
+describe('get_merge_request_file_diff', () => {
+    let mockGitLab;
+    let mockGitLabUrl;
+    before(async () => {
+        const mockPort = await findMockServerPort(9200);
+        mockGitLab = new MockGitLabServer({
+            port: mockPort,
+            validTokens: [MOCK_TOKEN]
+        });
+        await mockGitLab.start();
+        mockGitLabUrl = mockGitLab.getUrl();
+    });
+    after(async () => {
+        await mockGitLab.stop();
+    });
+    test('returns diffs for existing files in single page', async () => {
+        // Request only first few files that fit in one page (per_page=20)
+        const fileDiff = await callGetMergeRequestFileDiff({
+            project_id: TEST_PROJECT_ID,
+            merge_request_iid: TEST_MR_IID,
+            file_paths: ['src/index.ts', 'README.md']
+        }, {
+            GITLAB_API_URL: `${mockGitLabUrl}/api/v4`,
+            GITLAB_PERSONAL_ACCESS_TOKEN: MOCK_TOKEN
+        });
+        assert.ok(Array.isArray(fileDiff), 'Response should be an array');
+        assert.strictEqual(fileDiff.length, 2, 'Should return 2 diff results');
+        // Check that we got the correct files
+        const paths = fileDiff.map((f) => f.new_path || f.old_path).sort();
+        assert.deepStrictEqual(paths, ['README.md', 'src/index.ts'].sort());
+    });
+    test('handles pagination when result spans multiple pages', async () => {
+        // Request more files than fit in one page (we have 15 total, per_page defaults to 20)
+        // but let's use a smaller per_page by testing with unidiff param
+        const fileDiff = await callGetMergeRequestFileDiff({
+            project_id: TEST_PROJECT_ID,
+            merge_request_iid: TEST_MR_IID,
+            file_paths: [
+                'src/index.ts',
+                'config/settings.yml',
+                'models/user.go'
+            ]
+        }, {
+            GITLAB_API_URL: `${mockGitLabUrl}/api/v4`,
+            GITLAB_PERSONAL_ACCESS_TOKEN: MOCK_TOKEN
+        });
+        assert.ok(Array.isArray(fileDiff), 'Response should be an array');
+        assert.strictEqual(fileDiff.length, 3, 'Should return 3 diff results');
+    });
+    test('returns error objects for not-found files', async () => {
+        // Request some existing + non-existing files
+        const fileDiff = await callGetMergeRequestFileDiff({
+            project_id: TEST_PROJECT_ID,
+            merge_request_iid: TEST_MR_IID,
+            file_paths: ['src/index.ts', 'nonexistent/file.txt', 'also_missing.py']
+        }, {
+            GITLAB_API_URL: `${mockGitLabUrl}/api/v4`,
+            GITLAB_PERSONAL_ACCESS_TOKEN: MOCK_TOKEN
+        });
+        assert.ok(Array.isArray(fileDiff), 'Response should be an array');
+        // Should return 3 results: 1 success + 2 errors
+        assert.strictEqual(fileDiff.length, 3);
+        // Find the error entries
+        const errorEntries = fileDiff.filter((f) => f.error !== undefined);
+        const successEntries = fileDiff.filter((f) => f.error === undefined);
+        assert.strictEqual(errorEntries.length, 2, 'Should have 2 error entries');
+        assert.strictEqual(successEntries.length, 1, 'Should have 1 success entry');
+        // Verify error messages are helpful
+        const errorMsgs = errorEntries.map((e) => e.error);
+        assert.ok(errorMsgs.some(msg => msg.includes('nonexistent/file.txt')), 'Error message should mention nonexistent file');
+        assert.ok(errorMsgs.some(msg => msg.includes('also_missing.py')), 'Error message should mention other missing file');
+        // Check hint is present in at least one error
+        const hints = errorEntries.map((e) => e.hint).filter(Boolean);
+        assert.ok(hints.length > 0, 'Errors should include hints to check list_merge_request_changed_files');
+    });
+});

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

@@ -0,0 +1,272 @@
+/**
+ * Search Code Tools Test Suite
+ *
+ * Tests search_code, search_project_code, and search_group_code tools
+ * using the mock GitLab server and streamable HTTP transport.
+ */
+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-search-test-token";
+// Port bases that don't conflict with other test suites
+const MOCK_PORT_BASE = 9300;
+const MCP_PORT_BASE = 3300;
+let portCounter = 0;
+async function nextMcpPort() {
+    return findAvailablePort(MCP_PORT_BASE + portCounter++ * 10);
+}
+async function launchMcpServer(mockGitLabUrl, mcpPort, extraEnv = {}) {
+    return launchServer({
+        mode: TransportMode.STREAMABLE_HTTP,
+        port: mcpPort,
+        timeout: 10000,
+        env: {
+            STREAMABLE_HTTP: "true",
+            REMOTE_AUTHORIZATION: "true",
+            GITLAB_API_URL: `${mockGitLabUrl}/api/v4`,
+            ...extraEnv,
+        },
+    });
+}
+async function getToolNames(mcpUrl) {
+    const client = new CustomHeaderClient({
+        authorization: `Bearer ${MOCK_TOKEN}`,
+    });
+    await client.connect(mcpUrl);
+    const result = await client.listTools();
+    await client.disconnect();
+    return result.tools.map((t) => t.name);
+}
+async function callTool(mcpUrl, toolName, args = {}) {
+    const client = new CustomHeaderClient({
+        authorization: `Bearer ${MOCK_TOKEN}`,
+    });
+    await client.connect(mcpUrl);
+    const result = await client.callTool(toolName, args);
+    await client.disconnect();
+    // Parse the tool result content
+    const content = result?.content?.[0]?.text;
+    if (content) {
+        return JSON.parse(content);
+    }
+    return result;
+}
+// --- Tests ---
+let mockGitLab;
+let mockGitLabUrl;
+describe("Search Code Tools", () => {
+    before(async () => {
+        const mockPort = await findMockServerPort(MOCK_PORT_BASE);
+        mockGitLab = new MockGitLabServer({
+            port: mockPort,
+            validTokens: [MOCK_TOKEN],
+        });
+        await mockGitLab.start();
+        mockGitLabUrl = mockGitLab.getUrl();
+        console.log(`Mock GitLab: ${mockGitLabUrl}`);
+    });
+    after(async () => {
+        if (mockGitLab)
+            await mockGitLab.stop();
+    });
+    // ---- 1. search toolset exposes exactly 3 tools ----
+    describe("search toolset exposes exactly 3 tools", () => {
+        let server;
+        let tools;
+        before(async () => {
+            const port = await nextMcpPort();
+            server = await launchMcpServer(mockGitLabUrl, port, {
+                GITLAB_TOOLSETS: "search",
+            });
+            tools = await getToolNames(`http://${HOST}:${port}/mcp`);
+        });
+        after(() => cleanupServers([server]));
+        test("returns exactly 3 tools", () => {
+            assert.strictEqual(tools.length, 3, `Expected 3 tools but got ${tools.length}: ${tools.join(", ")}`);
+        });
+        test("includes search_code", () => {
+            assert.ok(tools.includes("search_code"), "Expected search_code to be present");
+        });
+        test("includes search_project_code", () => {
+            assert.ok(tools.includes("search_project_code"), "Expected search_project_code to be present");
+        });
+        test("includes search_group_code", () => {
+            assert.ok(tools.includes("search_group_code"), "Expected search_group_code to be present");
+        });
+    });
+    // ---- 2. search_code returns blob results ----
+    describe("search_code returns blob results", () => {
+        let server;
+        let mcpUrl;
+        before(async () => {
+            const port = await nextMcpPort();
+            server = await launchMcpServer(mockGitLabUrl, port, {
+                GITLAB_TOOLSETS: "search",
+            });
+            mcpUrl = `http://${HOST}:${port}/mcp`;
+        });
+        after(() => cleanupServers([server]));
+        test("returns array with blob fields", async () => {
+            const result = await callTool(mcpUrl, "search_code", { search: "searchResult" });
+            assert.ok(Array.isArray(result), "Response should be an array");
+            assert.ok(result.length > 0, "Response should have at least one result");
+            const first = result[0];
+            assert.ok("filename" in first, "Result should have filename field");
+            assert.ok("path" in first, "Result should have path field");
+            assert.ok("startline" in first, "Result should have startline field");
+        });
+        test("result has correct filename", async () => {
+            const result = await callTool(mcpUrl, "search_code", { search: "searchResult" });
+            assert.strictEqual(result[0].filename, "index.ts");
+        });
+        test("result has correct path", async () => {
+            const result = await callTool(mcpUrl, "search_code", { search: "searchResult" });
+            assert.strictEqual(result[0].path, "src/index.ts");
+        });
+        test("result has correct startline", async () => {
+            const result = await callTool(mcpUrl, "search_code", { search: "searchResult" });
+            assert.strictEqual(result[0].startline, 42);
+        });
+    });
+    // ---- 3. search_project_code returns blob results for project ----
+    describe("search_project_code returns blob results for project", () => {
+        let server;
+        let mcpUrl;
+        before(async () => {
+            const port = await nextMcpPort();
+            server = await launchMcpServer(mockGitLabUrl, port, {
+                GITLAB_TOOLSETS: "search",
+            });
+            mcpUrl = `http://${HOST}:${port}/mcp`;
+        });
+        after(() => cleanupServers([server]));
+        test("returns array with project_id", async () => {
+            const result = await callTool(mcpUrl, "search_project_code", {
+                project_id: "123",
+                search: "searchResult",
+            });
+            assert.ok(Array.isArray(result), "Response should be an array");
+            assert.ok(result.length > 0, "Response should have at least one result");
+        });
+        test("result includes the correct project_id", async () => {
+            const result = await callTool(mcpUrl, "search_project_code", {
+                project_id: "123",
+                search: "searchResult",
+            });
+            assert.strictEqual(String(result[0].project_id), "123", "project_id should match requested project");
+        });
+    });
+    // ---- 3b. search_project_code handles URL-encoded namespaced paths ----
+    describe("search_project_code handles URL-encoded namespaced paths", () => {
+        let server;
+        let mcpUrl;
+        before(async () => {
+            const port = await nextMcpPort();
+            server = await launchMcpServer(mockGitLabUrl, port, {
+                GITLAB_TOOLSETS: "search",
+            });
+            mcpUrl = `http://${HOST}:${port}/mcp`;
+        });
+        after(() => cleanupServers([server]));
+        test("URL-encoded project path is not double-encoded", async () => {
+            // Pass a URL-encoded namespaced path (e.g. "my-group%2Fmy-project")
+            // The mock echoes back req.params.id (which Express decodes from the URL).
+            // Correct: decode → "my-group/my-project" → encode → "my-group%2Fmy-project" → Express decodes to "my-group/my-project"
+            // Double-encoded: encode "my-group%2Fmy-project" → "my-group%252Fmy-project" → Express decodes to "my-group%2Fmy-project"
+            const result = await callTool(mcpUrl, "search_project_code", {
+                project_id: "my-group%2Fmy-project",
+                search: "searchResult",
+            });
+            assert.ok(Array.isArray(result), "Response should be an array");
+            assert.ok(result.length > 0, "Response should have at least one result");
+            assert.strictEqual(result[0].project_id, "my-group/my-project", "project_id should be decoded (not double-encoded as 'my-group%2Fmy-project')");
+        });
+        test("plain numeric project_id still works", async () => {
+            const result = await callTool(mcpUrl, "search_project_code", {
+                project_id: "123",
+                search: "searchResult",
+            });
+            assert.strictEqual(result[0].project_id, "123");
+        });
+    });
+    // ---- 4. search_group_code returns blob results for group ----
+    describe("search_group_code returns blob results for group", () => {
+        let server;
+        let mcpUrl;
+        before(async () => {
+            const port = await nextMcpPort();
+            server = await launchMcpServer(mockGitLabUrl, port, {
+                GITLAB_TOOLSETS: "search",
+            });
+            mcpUrl = `http://${HOST}:${port}/mcp`;
+        });
+        after(() => cleanupServers([server]));
+        test("returns array of results", async () => {
+            const result = await callTool(mcpUrl, "search_group_code", {
+                group_id: "456",
+                search: "searchResult",
+            });
+            assert.ok(Array.isArray(result), "Response should be an array");
+            assert.ok(result.length > 0, "Response should have at least one result");
+        });
+        test("result has expected blob fields", async () => {
+            const result = await callTool(mcpUrl, "search_group_code", {
+                group_id: "456",
+                search: "searchResult",
+            });
+            const first = result[0];
+            assert.ok("filename" in first, "Result should have filename field");
+            assert.ok("path" in first, "Result should have path field");
+        });
+    });
+    // ---- 4b. search_group_code handles URL-encoded namespaced paths ----
+    describe("search_group_code handles URL-encoded namespaced paths", () => {
+        let server;
+        let mcpUrl;
+        before(async () => {
+            const port = await nextMcpPort();
+            server = await launchMcpServer(mockGitLabUrl, port, {
+                GITLAB_TOOLSETS: "search",
+            });
+            mcpUrl = `http://${HOST}:${port}/mcp`;
+        });
+        after(() => cleanupServers([server]));
+        test("URL-encoded group path is not double-encoded", async () => {
+            // The mock echoes back req.params.id in the ref field.
+            // Correct: decode → "my-org/my-group" → encode → "my-org%2Fmy-group" → Express decodes to "my-org/my-group"
+            // Double-encoded: encode "my-org%2Fmy-group" → "my-org%252Fmy-group" → Express decodes to "my-org%2Fmy-group"
+            const result = await callTool(mcpUrl, "search_group_code", {
+                group_id: "my-org%2Fmy-group",
+                search: "searchResult",
+            });
+            assert.ok(Array.isArray(result), "Response should be an array");
+            assert.ok(result.length > 0, "Response should have at least one result");
+            assert.strictEqual(result[0].ref, "my-org/my-group", "ref should contain decoded group path (not double-encoded as 'my-org%2Fmy-group')");
+        });
+    });
+    // ---- 5. search tools are not available without search toolset enabled ----
+    describe("search tools are not available without search toolset enabled", () => {
+        let server;
+        let tools;
+        before(async () => {
+            const port = await nextMcpPort();
+            // Launch without GITLAB_TOOLSETS=search (use a different toolset instead)
+            server = await launchMcpServer(mockGitLabUrl, port, {
+                GITLAB_TOOLSETS: "issues",
+            });
+            tools = await getToolNames(`http://${HOST}:${port}/mcp`);
+        });
+        after(() => cleanupServers([server]));
+        test("search_code is NOT in tool list", () => {
+            assert.ok(!tools.includes("search_code"), "search_code should NOT be present without search toolset");
+        });
+        test("search_project_code is NOT in tool list", () => {
+            assert.ok(!tools.includes("search_project_code"), "search_project_code should NOT be present without search toolset");
+        });
+        test("search_group_code is NOT in tool list", () => {
+            assert.ok(!tools.includes("search_group_code"), "search_group_code should NOT be present without search toolset");
+        });
+    });
+});

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

@@ -16,17 +16,20 @@ const MOCK_PORT_BASE = 9200;
 const MCP_PORT_BASE = 3200;
 // Known tool counts per toolset (from TOOLSET_DEFINITIONS)
 const TOOLSET_TOOL_COUNTS = {
-    merge_requests: 31,
+    merge_requests: 34,
     issues: 14,
     repositories: 7,
     branches: 4,
     projects: 8,
     labels: 5,
-    pipelines: 12,
+    pipelines: 19,
     milestones: 9,
-    wiki: 5,
+    wiki: 10,
     releases: 7,
     users: 5,
+    search: 3,
+    workitems: 12,
+    webhooks: 3,
 };
 const DEFAULT_TOOLSETS = [
     "merge_requests",
@@ -41,6 +44,7 @@ const DEFAULT_TOOLSETS = [
     "releases",
     "users",
 ];
+const NON_DEFAULT_TOOLSETS = ["search", "webhooks"];
 const DEFAULT_TOOL_COUNT = DEFAULT_TOOLSETS.reduce((sum, id) => sum + TOOLSET_TOOL_COUNTS[id], 0);
 const ALL_TOOLSET_TOOL_COUNT = Object.values(TOOLSET_TOOL_COUNTS).reduce((sum, c) => sum + c, 0);
 // Representative tools per toolset for spot-checking
@@ -51,11 +55,13 @@ const TOOLSET_SAMPLE_TOOLS = {
     branches: ["create_branch", "list_commits"],
     projects: ["get_project", "list_namespaces", "list_group_iterations"],
     labels: ["list_labels", "create_label"],
-    pipelines: ["list_pipelines", "create_pipeline", "cancel_pipeline_job"],
+    pipelines: ["list_pipelines", "create_pipeline", "cancel_pipeline_job", "list_deployments", "list_job_artifacts"],
     milestones: ["list_milestones", "create_milestone", "get_milestone_burndown_events"],
-    wiki: ["list_wiki_pages", "create_wiki_page"],
+    wiki: ["list_wiki_pages", "create_wiki_page", "list_group_wiki_pages", "create_group_wiki_page"],
     releases: ["list_releases", "create_release", "download_release_asset"],
     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"],
 };
 // --- Helpers ---
 async function launchMcpServer(mockGitLabUrl, mcpPort, extraEnv = {}) {
@@ -97,7 +103,7 @@ let portCounter = 0;
 async function nextMcpPort() {
     return findAvailablePort(MCP_PORT_BASE + portCounter++ * 10);
 }
-describe("Toolset Filtering", () => {
+describe("Toolset Filtering", { concurrency: 1 }, () => {
     before(async () => {
         const mockPort = await findMockServerPort(MOCK_PORT_BASE);
         mockGitLab = new MockGitLabServer({
@@ -130,9 +136,8 @@ describe("Toolset Filtering", () => {
                 assertContainsAll(tools, TOOLSET_SAMPLE_TOOLS[id], id);
             }
         });
-        test("includes all toolsets by default (no non-default toolsets)", () => {
-            // All toolsets are now default, so default count equals all toolset count
-            assert.strictEqual(tools.length, ALL_TOOLSET_TOOL_COUNT);
+        test("excludes non-default toolsets (search)", () => {
+            assertContainsNone(tools, TOOLSET_SAMPLE_TOOLS.search, "non-default search");
         });
         test("excludes execute_graphql (not in any toolset)", () => {
             assertContainsNone(tools, ["execute_graphql"], "unassigned");
@@ -196,14 +201,14 @@ describe("Toolset Filtering", () => {
             tools = await getToolNames(`http://${HOST}:${port}/mcp`);
         });
         after(() => cleanupServers([server]));
-        test("returns default tools plus the two individual tools", () => {
-            assert.strictEqual(tools.length, DEFAULT_TOOL_COUNT + 2);
+        test("returns default tools plus execute_graphql (list_pipelines already in default)", () => {
+            assert.strictEqual(tools.length, DEFAULT_TOOL_COUNT + 1);
         });
         test("includes the individually added tools", () => {
             assertContainsAll(tools, ["list_pipelines", "execute_graphql"], "individual");
         });
-        test("does not include other pipeline tools", () => {
-            assertContainsNone(tools, ["create_pipeline", "cancel_pipeline"], "other pipelines");
+        test("includes pipeline tools from default toolset", () => {
+            assertContainsAll(tools, ["create_pipeline", "cancel_pipeline"], "default pipelines");
         });
     });
     // ---- 5. Toolset + individual tools combined ----
@@ -262,8 +267,8 @@ describe("Toolset Filtering", () => {
             tools = await getToolNames(`http://${HOST}:${port}/mcp`);
         });
         after(() => cleanupServers([server]));
-        test("returns default tools + wiki tools", () => {
-            assert.strictEqual(tools.length, DEFAULT_TOOL_COUNT + TOOLSET_TOOL_COUNTS.wiki);
+        test("returns default tool count (wiki is already default)", () => {
+            assert.strictEqual(tools.length, DEFAULT_TOOL_COUNT);
         });
         test("includes wiki tools", () => {
             assertContainsAll(tools, TOOLSET_SAMPLE_TOOLS.wiki, "wiki");
@@ -425,8 +430,8 @@ describe("Toolset Filtering", () => {
         test("resolves mixed-case tool names to lowercase equivalents", () => {
             assertContainsAll(tools, ["list_pipelines", "execute_graphql"], "case-insensitive tools");
         });
-        test("returns default tools plus the two individual tools", () => {
-            assert.strictEqual(tools.length, DEFAULT_TOOL_COUNT + 2);
+        test("returns default tools plus execute_graphql (list_pipelines already in default)", () => {
+            assert.strictEqual(tools.length, DEFAULT_TOOL_COUNT + 1);
         });
     });
     // ---- 15. GITLAB_TOOLS with unknown tool names ----