@zereight/mcp-gitlab 2.0.33 → 2.0.35

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 ----

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

@@ -0,0 +1,148 @@
+import { describe, test, before, after } from 'node:test';
+import assert from 'node:assert';
+import { spawn } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { MockGitLabServer, findMockServerPort } from './utils/mock-gitlab-server.js';
+const MOCK_TOKEN = 'glpat-mock-token-12345';
+const TEST_PROJECT_ID = '123';
+function callUploadMarkdown(args, env, timeoutMs = 15_000) {
+    return new Promise((resolve, reject) => {
+        const proc = spawn('node', ['build/index.js'], {
+            stdio: ['pipe', 'pipe', 'pipe'],
+            env: { ...process.env, ...env },
+        });
+        const timer = setTimeout(() => {
+            proc.kill();
+            reject(new Error(`Process timed out after ${timeoutMs}ms`));
+        }, timeoutMs);
+        let stdout = '';
+        let stderr = '';
+        proc.stdout?.on('data', (d) => (stdout += d.toString()));
+        proc.stderr?.on('data', (d) => (stderr += d.toString()));
+        proc.on('error', (err) => {
+            clearTimeout(timer);
+            reject(new Error(`Failed to spawn process: ${err.message}`));
+        });
+        proc.on('close', () => {
+            clearTimeout(timer);
+            const lines = stdout.split('\n').filter(l => l.trim().startsWith('{'));
+            for (const line of lines) {
+                try {
+                    const parsed = JSON.parse(line);
+                    if (parsed.id === 1) {
+                        resolve(parsed);
+                        return;
+                    }
+                }
+                catch { /* try next line */ }
+            }
+            reject(new Error(`No matching JSON-RPC response found.\nstdout: ${stdout}\nstderr: ${stderr}`));
+        });
+        proc.stdin?.end(JSON.stringify({
+            jsonrpc: '2.0',
+            id: 1,
+            method: 'tools/call',
+            params: { name: 'upload_markdown', arguments: args },
+        }) + '\n');
+    });
+}
+const MOCK_UPLOAD_RESPONSE = {
+    id: 42,
+    alt: 'test-file.txt',
+    url: '/uploads/abc123secret/test-file.txt',
+    full_path: '/test-group/test-project/uploads/abc123secret/test-file.txt',
+    markdown: '[test-file.txt](/uploads/abc123secret/test-file.txt)',
+};
+describe('upload_markdown', () => {
+    let mockGitLab;
+    let env;
+    // Captured per-request state, reset before each invocation via the handler
+    let lastContentType;
+    let lastRawBody;
+    before(async () => {
+        const port = await findMockServerPort(9200);
+        mockGitLab = new MockGitLabServer({ port, validTokens: [MOCK_TOKEN] });
+        await mockGitLab.start();
+        env = {
+            GITLAB_API_URL: `${mockGitLab.getUrl()}/api/v4`,
+            GITLAB_PERSONAL_ACCESS_TOKEN: MOCK_TOKEN,
+        };
+        mockGitLab.addMockHandler('post', `/projects/${TEST_PROJECT_ID}/uploads`, (req, res) => {
+            lastContentType = req.headers['content-type'];
+            const chunks = [];
+            req.on('data', (chunk) => chunks.push(chunk));
+            req.on('end', () => {
+                lastRawBody = Buffer.concat(chunks).toString('binary');
+                res.status(201).json(MOCK_UPLOAD_RESPONSE);
+            });
+        });
+    });
+    after(async () => {
+        await mockGitLab.stop();
+    });
+    test('Content-Type is multipart/form-data with a boundary', async () => {
+        const tmpFile = path.join(os.tmpdir(), 'mcp-upload-ct-test.txt');
+        fs.writeFileSync(tmpFile, 'content-type test');
+        try {
+            await callUploadMarkdown({ project_id: TEST_PROJECT_ID, file_path: tmpFile }, env);
+            assert.ok(lastContentType, 'Content-Type header must be present');
+            assert.ok(lastContentType.startsWith('multipart/form-data'), `Expected multipart/form-data, got: ${lastContentType}`);
+            assert.ok(lastContentType.includes('boundary='), `Content-Type must include boundary, got: ${lastContentType}`);
+        }
+        finally {
+            fs.unlinkSync(tmpFile);
+        }
+    });
+    test('multipart body contains a "file" field with the file content', async () => {
+        const tmpFile = path.join(os.tmpdir(), 'mcp-upload-body-test.txt');
+        const fileContent = 'hello from multipart upload test';
+        fs.writeFileSync(tmpFile, fileContent);
+        try {
+            await callUploadMarkdown({ project_id: TEST_PROJECT_ID, file_path: tmpFile }, env);
+            assert.ok(lastRawBody, 'Request body must be captured');
+            assert.ok(lastRawBody.includes('name="file"'), 'Multipart body should include a field named "file"');
+            assert.ok(lastRawBody.includes(fileContent), 'Multipart body should contain the uploaded file content');
+        }
+        finally {
+            fs.unlinkSync(tmpFile);
+        }
+    });
+    test('multipart body includes the original filename', async () => {
+        const tmpFile = path.join(os.tmpdir(), 'mcp-upload-filename-check.txt');
+        fs.writeFileSync(tmpFile, 'filename check');
+        try {
+            await callUploadMarkdown({ project_id: TEST_PROJECT_ID, file_path: tmpFile }, env);
+            assert.ok(lastRawBody, 'Request body must be captured');
+            assert.ok(lastRawBody.includes('mcp-upload-filename-check.txt'), 'Multipart body should include the original filename');
+        }
+        finally {
+            fs.unlinkSync(tmpFile);
+        }
+    });
+    test('returns markdown, url, alt, and full_path from upload response', async () => {
+        const tmpFile = path.join(os.tmpdir(), 'mcp-upload-response-test.txt');
+        fs.writeFileSync(tmpFile, 'response field test');
+        try {
+            const raw = await callUploadMarkdown({ project_id: TEST_PROJECT_ID, file_path: tmpFile }, env);
+            assert.ok(!raw.error, `Unexpected RPC error: ${raw.error?.message}`);
+            const text = raw.result?.content?.[0]?.text;
+            assert.ok(text, 'Result should contain a text content block');
+            const parsed = JSON.parse(text);
+            assert.strictEqual(parsed.markdown, MOCK_UPLOAD_RESPONSE.markdown);
+            assert.strictEqual(parsed.url, MOCK_UPLOAD_RESPONSE.url);
+            assert.strictEqual(parsed.alt, MOCK_UPLOAD_RESPONSE.alt);
+            assert.strictEqual(parsed.full_path, MOCK_UPLOAD_RESPONSE.full_path);
+        }
+        finally {
+            fs.unlinkSync(tmpFile);
+        }
+    });
+    test('returns an error when the file does not exist', async () => {
+        const raw = await callUploadMarkdown({ project_id: TEST_PROJECT_ID, file_path: '/nonexistent/no-such-file.txt' }, env);
+        const hasError = typeof raw.error?.message === 'string' ||
+            raw.result?.content?.some(c => c.text && (c.text.toLowerCase().includes('not found') || c.text.toLowerCase().includes('error')));
+        assert.ok(hasError, 'Should return an error for a nonexistent file path');
+    });
+});