@zereight/mcp-gitlab 2.0.28 → 2.0.32

package/build/test/test-download-attachment.js

@@ -0,0 +1,144 @@
+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 { MockGitLabServer, findMockServerPort } from './utils/mock-gitlab-server.js';
+const MOCK_TOKEN = 'glpat-mock-token-12345';
+const TEST_PROJECT_ID = '123';
+const TEST_SECRET = 'testsecret123';
+// Minimum valid 1x1 transparent PNG
+const MINIMAL_PNG_BUF = Buffer.from('iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==', 'base64');
+// Unique suffix per test run to avoid conflicts on concurrent executions
+const RUN_ID = Math.random().toString(36).slice(2, 8);
+/**
+ * Spawn build/index.js, send a single download_attachment JSON-RPC call, and
+ * return the raw parsed JSON-RPC response (either {result:...} or {error:...}).
+ */
+function callDownloadAttachment(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, GITLAB_READ_ONLY_MODE: 'true' },
+        });
+        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);
+            // Find the JSON-RPC response line matching our request id
+            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.\nstderr: ${stderr}`));
+        });
+        proc.stdin?.end(JSON.stringify({
+            jsonrpc: '2.0',
+            id: 1,
+            method: 'tools/call',
+            params: { name: 'download_attachment', arguments: args },
+        }) + '\n');
+    });
+}
+describe('download_attachment', () => {
+    let mockGitLab;
+    let env;
+    before(async () => {
+        const port = await findMockServerPort(9100);
+        mockGitLab = new MockGitLabServer({ port, validTokens: [MOCK_TOKEN] });
+        await mockGitLab.start();
+        env = {
+            GITLAB_API_URL: `${mockGitLab.getUrl()}/api/v4`,
+            GITLAB_PERSONAL_ACCESS_TOKEN: MOCK_TOKEN,
+        };
+        // PNG upload endpoint
+        mockGitLab.addMockHandler('get', `/projects/${TEST_PROJECT_ID}/uploads/${TEST_SECRET}/image.png`, (_req, res) => { res.set('Content-Type', 'image/png').send(MINIMAL_PNG_BUF); });
+        // Plain-text upload endpoint
+        mockGitLab.addMockHandler('get', `/projects/${TEST_PROJECT_ID}/uploads/${TEST_SECRET}/document.txt`, (_req, res) => { res.set('Content-Type', 'text/plain').send('hello world'); });
+    });
+    after(async () => {
+        await mockGitLab.stop();
+    });
+    test('image file without local_path returns base64 image content block', async () => {
+        const raw = await callDownloadAttachment({ project_id: TEST_PROJECT_ID, secret: TEST_SECRET, filename: 'image.png' }, env);
+        const content = raw.result?.content;
+        assert.ok(Array.isArray(content), 'result.content should be an array');
+        const imageBlock = content.find(c => c.type === 'image');
+        assert.ok(imageBlock, 'Should contain an image content block');
+        assert.strictEqual(imageBlock.mimeType, 'image/png', 'mimeType should be image/png');
+        assert.ok(typeof imageBlock.data === 'string' && imageBlock.data.length > 0, 'Image block should have non-empty base64 data');
+    });
+    test('non-image file is saved to disk and returns file_path', async () => {
+        const raw = await callDownloadAttachment({ project_id: TEST_PROJECT_ID, secret: TEST_SECRET, filename: 'document.txt' }, env);
+        const text = raw.result?.content?.[0]?.text;
+        assert.ok(text, 'Should have text content');
+        const parsed = JSON.parse(text);
+        try {
+            assert.strictEqual(parsed.success, true, 'success should be true');
+            assert.ok(typeof parsed.file_path === 'string', 'file_path should be a string');
+            assert.ok(parsed.file_path.endsWith('document.txt'), 'file_path should end with document.txt');
+        }
+        finally {
+            if (parsed.file_path && fs.existsSync(parsed.file_path)) {
+                fs.unlinkSync(parsed.file_path);
+            }
+        }
+    });
+    test('image file with local_path is saved to disk and returns file_path', async () => {
+        // Must be a relative path – the implementation rejects absolute paths as traversal
+        const localPath = `omc-test-save-${RUN_ID}`;
+        try {
+            const raw = await callDownloadAttachment({ project_id: TEST_PROJECT_ID, secret: TEST_SECRET, filename: 'image.png', local_path: localPath }, env);
+            const text = raw.result?.content?.[0]?.text;
+            assert.ok(text, 'Should have text content');
+            const parsed = JSON.parse(text);
+            assert.strictEqual(parsed.success, true, 'success should be true');
+            assert.ok(typeof parsed.file_path === 'string', 'file_path should be a string');
+            assert.ok(parsed.file_path.includes('image.png'), 'file_path should include image.png');
+        }
+        finally {
+            fs.rmSync(localPath, { recursive: true, force: true });
+        }
+    });
+    test('local_path with ".." returns path traversal error', async () => {
+        const raw = await callDownloadAttachment({ project_id: TEST_PROJECT_ID, secret: TEST_SECRET, filename: 'image.png', local_path: '../../../tmp' }, env);
+        // MCP SDK may return a JSON-RPC error or an isError content block; both must mention "traversal"
+        const isRpcError = typeof raw.error?.message === 'string' &&
+            raw.error.message.toLowerCase().includes('traversal');
+        const isContentError = Array.isArray(raw.result?.content) &&
+            raw.result.content.some(c => typeof c.text === 'string' && c.text.toLowerCase().includes('traversal'));
+        assert.ok(isRpcError || isContentError, 'Should return an error mentioning directory traversal');
+    });
+    test('non-existent local_path directory is auto-created before saving', async () => {
+        const baseDir = `omc-test-newdir-${RUN_ID}`;
+        const localPath = `${baseDir}/subdir`;
+        fs.rmSync(baseDir, { recursive: true, force: true });
+        try {
+            const raw = await callDownloadAttachment({ project_id: TEST_PROJECT_ID, secret: TEST_SECRET, filename: 'document.txt', local_path: localPath }, env);
+            const text = raw.result?.content?.[0]?.text;
+            assert.ok(text, 'Should have text content');
+            const parsed = JSON.parse(text);
+            assert.strictEqual(parsed.success, true, 'success should be true');
+            assert.ok(fs.existsSync(parsed.file_path), 'Saved file should exist on disk');
+        }
+        finally {
+            fs.rmSync(baseDir, { recursive: true, force: true });
+        }
+    });
+});

package/build/test/test-job-artifacts.js

@@ -0,0 +1,194 @@
+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';
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+const MOCK_TOKEN = 'glpat-mock-token-12345';
+const TEST_PROJECT_ID = '123';
+const TEST_JOB_ID = '456';
+const TEST_ENCODED_ARTIFACT_PATH = 'reports/report#1.txt';
+// Helper to run an MCP tool via the built server
+async function callTool(toolName, args, env) {
+    return new Promise((resolve, reject) => {
+        const proc = spawn('node', ['build/index.js'], {
+            stdio: ['pipe', 'pipe', 'pipe'],
+            env: {
+                ...process.env,
+                ...env,
+                GITLAB_READ_ONLY_MODE: 'true',
+                USE_PIPELINE: 'true',
+            },
+        });
+        let output = '';
+        let errorOutput = '';
+        proc.stdout?.on('data', (d) => (output += d));
+        proc.stderr?.on('data', (d) => (errorOutput += d));
+        proc.on('close', (code) => {
+            if (code !== 0)
+                return reject(new Error(`Process exited with code ${code}: ${errorOutput}`));
+            const line = output.split('\n').find((l) => l.startsWith('{'));
+            if (!line)
+                return reject(new Error('No JSON output found'));
+            try {
+                const response = JSON.parse(line);
+                if (response.error) {
+                    reject(response.error);
+                }
+                else {
+                    const content = response.result?.content?.[0]?.text;
+                    if (content) {
+                        try {
+                            resolve(JSON.parse(content));
+                        }
+                        catch {
+                            // Not JSON (plain text response)
+                            resolve(content);
+                        }
+                    }
+                    else {
+                        resolve(response.result);
+                    }
+                }
+            }
+            catch (e) {
+                reject(e);
+            }
+        });
+        proc.stdin?.end(JSON.stringify({
+            jsonrpc: '2.0',
+            id: 1,
+            method: 'tools/call',
+            params: { name: toolName, arguments: args },
+        }) + '\n');
+    });
+}
+describe('job artifacts tools', () => {
+    let mockGitLab;
+    let mockGitLabUrl;
+    let tmpDir;
+    before(async () => {
+        const mockPort = await findMockServerPort(9200);
+        mockGitLab = new MockGitLabServer({
+            port: mockPort,
+            validTokens: [MOCK_TOKEN],
+        });
+        // Add mock handler for artifact tree listing
+        mockGitLab.addMockHandler('get', `/projects/${TEST_PROJECT_ID}/jobs/${TEST_JOB_ID}/artifacts/tree`, (req, res) => {
+            res.json([
+                {
+                    name: 'report.xml',
+                    path: 'report.xml',
+                    type: 'file',
+                    size: 1024,
+                    mode: '100644',
+                },
+                {
+                    name: 'logs',
+                    path: 'logs',
+                    type: 'directory',
+                    mode: '040755',
+                },
+                {
+                    name: 'output.log',
+                    path: 'logs/output.log',
+                    type: 'file',
+                    size: 512,
+                    mode: '100644',
+                },
+            ]);
+        });
+        // Add mock handler for downloading the full artifact archive
+        mockGitLab.addMockHandler('get', `/projects/${TEST_PROJECT_ID}/jobs/${TEST_JOB_ID}/artifacts`, (req, res) => {
+            // Return a minimal zip-like binary content for testing
+            const fakeZipContent = Buffer.from('PK\x03\x04fake-zip-content-for-testing');
+            res.set('Content-Type', 'application/zip');
+            res.set('Content-Disposition', `attachment; filename="artifacts_job_${TEST_JOB_ID}.zip"`);
+            res.send(fakeZipContent);
+        });
+        // Add mock handler for getting a single artifact file
+        mockGitLab.addMockHandler('get', `/projects/${TEST_PROJECT_ID}/jobs/${TEST_JOB_ID}/artifacts/report.xml`, (req, res) => {
+            res.set('Content-Type', 'application/xml');
+            res.send('<testsuites><testsuite name="unit" tests="5" failures="1"></testsuite></testsuites>');
+        });
+        // Add mock handler for path that requires URL encoding
+        mockGitLab.addMockHandler('get', `/projects/${TEST_PROJECT_ID}/jobs/${TEST_JOB_ID}/artifacts/reports/report%231.txt`, (req, res) => {
+            res.set('Content-Type', 'text/plain');
+            res.send('encoded artifact content');
+        });
+        // Add mock handler for 404 on non-existent artifact
+        mockGitLab.addMockHandler('get', `/projects/${TEST_PROJECT_ID}/jobs/999/artifacts/tree`, (req, res) => {
+            res.status(404).json({ message: 'Not Found' });
+        });
+        await mockGitLab.start();
+        mockGitLabUrl = mockGitLab.getUrl();
+        // Create a temp directory for download tests
+        tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'gitlab-mcp-test-'));
+    });
+    after(async () => {
+        await mockGitLab.stop();
+        // Clean up temp directory
+        if (tmpDir && fs.existsSync(tmpDir)) {
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+        }
+    });
+    test('list_job_artifacts returns artifact entries', async () => {
+        const result = await callTool('list_job_artifacts', { project_id: TEST_PROJECT_ID, job_id: TEST_JOB_ID }, {
+            GITLAB_API_URL: `${mockGitLabUrl}/api/v4`,
+            GITLAB_PERSONAL_ACCESS_TOKEN: MOCK_TOKEN,
+        });
+        assert.ok(Array.isArray(result), 'Response should be an array');
+        assert.strictEqual(result.length, 3, 'Should return 3 artifact entries');
+        assert.strictEqual(result[0].name, 'report.xml');
+        assert.strictEqual(result[0].type, 'file');
+        assert.strictEqual(result[0].size, 1024);
+        assert.strictEqual(result[1].name, 'logs');
+        assert.strictEqual(result[1].type, 'directory');
+    });
+    test('download_job_artifacts saves archive to disk', async () => {
+        const result = await callTool('download_job_artifacts', { project_id: TEST_PROJECT_ID, job_id: TEST_JOB_ID, local_path: tmpDir }, {
+            GITLAB_API_URL: `${mockGitLabUrl}/api/v4`,
+            GITLAB_PERSONAL_ACCESS_TOKEN: MOCK_TOKEN,
+        });
+        assert.ok(result.success, 'Download should succeed');
+        assert.ok(result.file_path.endsWith('.zip'), 'File should have .zip extension');
+        assert.ok(fs.existsSync(result.file_path), `File should exist at ${result.file_path}`);
+        const stats = fs.statSync(result.file_path);
+        assert.ok(stats.size > 0, 'Downloaded file should not be empty');
+    });
+    test('download_job_artifacts creates nested destination directories', async () => {
+        const nestedLocalPath = path.join(tmpDir, 'artifacts', 'run-42');
+        const result = await callTool('download_job_artifacts', { project_id: TEST_PROJECT_ID, job_id: TEST_JOB_ID, local_path: nestedLocalPath }, {
+            GITLAB_API_URL: `${mockGitLabUrl}/api/v4`,
+            GITLAB_PERSONAL_ACCESS_TOKEN: MOCK_TOKEN,
+        });
+        assert.ok(result.success, 'Download should succeed');
+        assert.ok(fs.existsSync(result.file_path), `File should exist at ${result.file_path}`);
+        assert.ok(fs.existsSync(nestedLocalPath), `Directory should be created at ${nestedLocalPath}`);
+    });
+    test('get_job_artifact_file returns file content', async () => {
+        const result = await callTool('get_job_artifact_file', {
+            project_id: TEST_PROJECT_ID,
+            job_id: TEST_JOB_ID,
+            artifact_path: 'report.xml',
+        }, {
+            GITLAB_API_URL: `${mockGitLabUrl}/api/v4`,
+            GITLAB_PERSONAL_ACCESS_TOKEN: MOCK_TOKEN,
+        });
+        assert.ok(typeof result === 'string', 'Response should be a string');
+        assert.ok(result.includes('<testsuites>'), 'Should contain XML content');
+        assert.ok(result.includes('failures="1"'), 'Should contain failure data');
+    });
+    test('get_job_artifact_file handles artifact paths with reserved characters', async () => {
+        const result = await callTool('get_job_artifact_file', {
+            project_id: TEST_PROJECT_ID,
+            job_id: TEST_JOB_ID,
+            artifact_path: TEST_ENCODED_ARTIFACT_PATH,
+        }, {
+            GITLAB_API_URL: `${mockGitLabUrl}/api/v4`,
+            GITLAB_PERSONAL_ACCESS_TOKEN: MOCK_TOKEN,
+        });
+        assert.strictEqual(result, 'encoded artifact content');
+    });
+});

package/build/test/test-merge-request-approval-state-tools.js

@@ -0,0 +1,171 @@
+import { after, before, describe, test } 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-approval";
+const TEST_PROJECT_ID = "123";
+const TEST_MR_IID_WITH_FALLBACK = "88";
+const TEST_MR_IID_WITH_APPROVAL_STATE = "89";
+async function callTool(toolName, args, env) {
+    return new Promise((resolve, reject) => {
+        const proc = spawn("node", ["build/index.js"], {
+            stdio: ["pipe", "pipe", "pipe"],
+            env: {
+                ...process.env,
+                ...env,
+                GITLAB_READ_ONLY_MODE: "true",
+                USE_PIPELINE: "true",
+            },
+        });
+        let output = "";
+        let errorOutput = "";
+        proc.stdout?.on("data", (d) => (output += d));
+        proc.stderr?.on("data", (d) => (errorOutput += d));
+        proc.on("close", (code) => {
+            if (code !== 0) {
+                return reject(new Error(`Process exited with code ${code}: ${errorOutput}`));
+            }
+            const line = output.split("\n").find(l => l.startsWith("{"));
+            if (!line) {
+                return reject(new Error("No JSON output found"));
+            }
+            try {
+                const response = JSON.parse(line);
+                if (response.error) {
+                    reject(response.error);
+                }
+                else {
+                    const content = response.result?.content?.[0]?.text;
+                    if (content) {
+                        try {
+                            resolve(JSON.parse(content));
+                        }
+                        catch {
+                            resolve(content);
+                        }
+                    }
+                    else {
+                        resolve(response.result);
+                    }
+                }
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+        proc.stdin?.end(JSON.stringify({
+            jsonrpc: "2.0",
+            id: 1,
+            method: "tools/call",
+            params: { name: toolName, arguments: args },
+        }) + "\n");
+    });
+}
+describe("merge request approval state tools", () => {
+    let mockGitLab;
+    let mockGitLabUrl;
+    before(async () => {
+        const mockPort = await findMockServerPort(9400);
+        mockGitLab = new MockGitLabServer({
+            port: mockPort,
+            validTokens: [MOCK_TOKEN],
+        });
+        mockGitLab.addMockHandler("get", `/projects/${TEST_PROJECT_ID}/merge_requests/${TEST_MR_IID_WITH_FALLBACK}/approval_state`, (_req, res) => {
+            res.status(404).json({ error: "404 Not Found" });
+        });
+        mockGitLab.addMockHandler("get", `/projects/${TEST_PROJECT_ID}/merge_requests/${TEST_MR_IID_WITH_FALLBACK}/approvals`, (_req, res) => {
+            res.json({
+                approved: true,
+                user_has_approved: false,
+                user_can_approve: true,
+                approved_by: [
+                    {
+                        user: {
+                            id: "35",
+                            username: "sergey.kravchenya",
+                            name: "Sergey Kravchenya",
+                            state: "active",
+                            avatar_url: "https://gitlab.mock/uploads/avatar.png",
+                            web_url: "https://gitlab.mock/sergey.kravchenya",
+                        },
+                    },
+                ],
+            });
+        });
+        mockGitLab.addMockHandler("get", `/projects/${TEST_PROJECT_ID}/merge_requests/${TEST_MR_IID_WITH_APPROVAL_STATE}/approval_state`, (_req, res) => {
+            res.json({
+                approval_rules_overwritten: false,
+                rules: [
+                    {
+                        id: "101",
+                        name: "Default rule",
+                        rule_type: "regular",
+                        approvals_required: 1,
+                        approved: true,
+                        approved_by: [
+                            {
+                                id: "35",
+                                username: "sergey.kravchenya",
+                                name: "Sergey Kravchenya",
+                                state: "active",
+                                avatar_url: "https://gitlab.mock/uploads/avatar.png",
+                                web_url: "https://gitlab.mock/sergey.kravchenya",
+                            },
+                        ],
+                    },
+                    {
+                        id: "102",
+                        name: "Code owners",
+                        rule_type: "code_owner",
+                        approvals_required: 1,
+                        approved: true,
+                        approved_by: [
+                            {
+                                id: "35",
+                                username: "sergey.kravchenya",
+                                name: "Sergey Kravchenya",
+                                state: "active",
+                                avatar_url: "https://gitlab.mock/uploads/avatar.png",
+                                web_url: "https://gitlab.mock/sergey.kravchenya",
+                            },
+                        ],
+                    },
+                ],
+            });
+        });
+        await mockGitLab.start();
+        mockGitLabUrl = mockGitLab.getUrl();
+    });
+    after(async () => {
+        await mockGitLab.stop();
+    });
+    test("falls back to approvals endpoint when approval_state is unavailable", async () => {
+        const result = await callTool("get_merge_request_approval_state", {
+            project_id: TEST_PROJECT_ID,
+            merge_request_iid: TEST_MR_IID_WITH_FALLBACK,
+        }, {
+            GITLAB_API_URL: `${mockGitLabUrl}/api/v4`,
+            GITLAB_PERSONAL_ACCESS_TOKEN: MOCK_TOKEN,
+        });
+        assert.strictEqual(result.source_endpoint, "approvals");
+        assert.strictEqual(result.approved, true);
+        assert.deepStrictEqual(result.approved_by_usernames, ["sergey.kravchenya"]);
+        assert.ok(Array.isArray(result.approved_by));
+        assert.strictEqual(result.approved_by[0].username, "sergey.kravchenya");
+    });
+    test("returns deduplicated approvers from approval_state rules", async () => {
+        const result = await callTool("get_merge_request_approval_state", {
+            project_id: TEST_PROJECT_ID,
+            merge_request_iid: TEST_MR_IID_WITH_APPROVAL_STATE,
+        }, {
+            GITLAB_API_URL: `${mockGitLabUrl}/api/v4`,
+            GITLAB_PERSONAL_ACCESS_TOKEN: MOCK_TOKEN,
+        });
+        assert.strictEqual(result.source_endpoint, "approval_state");
+        assert.strictEqual(result.rules.length, 2);
+        assert.deepStrictEqual(result.approved_by_usernames, ["sergey.kravchenya"]);
+        assert.ok(Array.isArray(result.approved_by));
+        assert.strictEqual(result.approved_by.length, 1);
+        assert.strictEqual(result.approved_by[0].username, "sergey.kravchenya");
+    });
+});