@zereight/mcp-gitlab 2.0.23 → 2.0.25

package/build/test/test-merge-request-approvals.js

@@ -0,0 +1,187 @@
+#!/usr/bin/env npx ts-node
+/**
+ * Test script for merge request approval tools
+ *
+ * Usage:
+ *   GITLAB_PERSONAL_ACCESS_TOKEN=<token> GITLAB_PROJECT_ID=<project> npx ts-node test/test-merge-request-approvals.ts
+ *
+ * Optional: Set MERGE_REQUEST_IID to test a specific merge request
+ */
+import { spawn } from "child_process";
+import path from "path";
+import { fileURLToPath } from "url";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const GITLAB_TOKEN = process.env.GITLAB_PERSONAL_ACCESS_TOKEN || process.env.GITLAB_TOKEN;
+const GITLAB_PROJECT_ID = process.env.GITLAB_PROJECT_ID;
+const GITLAB_API_URL = process.env.GITLAB_API_URL || "https://gitlab.com/api/v4";
+const MERGE_REQUEST_IID = process.env.MERGE_REQUEST_IID;
+async function sendMcpRequest(serverProcess, method, params) {
+    return new Promise((resolve, reject) => {
+        const request = {
+            jsonrpc: "2.0",
+            id: Date.now(),
+            method,
+            params,
+        };
+        let responseData = "";
+        const onData = (data) => {
+            responseData += data.toString();
+            const lines = responseData.split("\n");
+            for (const line of lines) {
+                if (line.trim()) {
+                    try {
+                        const parsed = JSON.parse(line);
+                        serverProcess.stdout?.off("data", onData);
+                        resolve(parsed);
+                        return;
+                    }
+                    catch {
+                        // Continue accumulating data
+                    }
+                }
+            }
+        };
+        serverProcess.stdout?.on("data", onData);
+        serverProcess.stdin?.write(JSON.stringify(request) + "\n");
+        setTimeout(() => {
+            serverProcess.stdout?.off("data", onData);
+            reject(new Error("Request timeout"));
+        }, 30000);
+    });
+}
+async function runTests() {
+    console.log("=== Merge Request Approval Tools Test ===\n");
+    if (!GITLAB_TOKEN) {
+        console.error("Error: GITLAB_PERSONAL_ACCESS_TOKEN or GITLAB_TOKEN environment variable is required");
+        process.exit(1);
+    }
+    if (!GITLAB_PROJECT_ID) {
+        console.error("Error: GITLAB_PROJECT_ID environment variable is required");
+        process.exit(1);
+    }
+    console.log(`GitLab API URL: ${GITLAB_API_URL}`);
+    console.log(`Project ID: ${GITLAB_PROJECT_ID}`);
+    console.log(`Merge Request IID: ${MERGE_REQUEST_IID || "(will find one)"}\n`);
+    // Start the MCP server
+    const serverPath = path.join(__dirname, "..", "build", "index.js");
+    const serverProcess = spawn("node", [serverPath], {
+        env: {
+            ...process.env,
+            GITLAB_PERSONAL_ACCESS_TOKEN: GITLAB_TOKEN,
+            GITLAB_API_URL,
+        },
+        stdio: ["pipe", "pipe", "pipe"],
+    });
+    serverProcess.stderr?.on("data", data => {
+        const msg = data.toString();
+        if (!msg.includes("GitLab MCP Server running")) {
+            console.error("Server stderr:", msg);
+        }
+    });
+    // Wait for server to start
+    await new Promise(resolve => setTimeout(resolve, 2000));
+    try {
+        // Initialize the MCP connection
+        console.log("1. Initializing MCP connection...");
+        await sendMcpRequest(serverProcess, "initialize", {
+            protocolVersion: "2024-11-05",
+            capabilities: {},
+            clientInfo: { name: "test-client", version: "1.0.0" },
+        });
+        console.log("   ✓ Connected\n");
+        // Find a merge request to test with
+        let mrIid = MERGE_REQUEST_IID;
+        if (!mrIid) {
+            console.log("2. Finding an open merge request...");
+            const listResponse = await sendMcpRequest(serverProcess, "tools/call", {
+                name: "list_merge_requests",
+                arguments: {
+                    project_id: GITLAB_PROJECT_ID,
+                    state: "opened",
+                    per_page: 1,
+                },
+            });
+            if (listResponse.error) {
+                console.error("   ✗ Error:", listResponse.error.message);
+                process.exit(1);
+            }
+            const mrs = JSON.parse(listResponse.result?.content?.[0]?.text || "[]");
+            if (mrs.length === 0) {
+                console.log("   ⚠ No open merge requests found. Create one to test approval tools.");
+                process.exit(0);
+            }
+            mrIid = mrs[0].iid;
+            console.log(`   ✓ Found MR !${mrIid}: ${mrs[0].title}\n`);
+        }
+        // Test get_merge_request_approval_state
+        console.log("3. Testing get_merge_request_approval_state...");
+        const approvalStateResponse = await sendMcpRequest(serverProcess, "tools/call", {
+            name: "get_merge_request_approval_state",
+            arguments: {
+                project_id: GITLAB_PROJECT_ID,
+                merge_request_iid: mrIid,
+            },
+        });
+        if (approvalStateResponse.error) {
+            console.error("   ✗ Error:", approvalStateResponse.error.message);
+        }
+        else {
+            const state = JSON.parse(approvalStateResponse.result?.content?.[0]?.text || "{}");
+            console.log("   ✓ Got approval state");
+            console.log(`     Rules: ${state.rules?.length || 0}`);
+            // Show details for each rule
+            for (const rule of state.rules || []) {
+                const approvedBy = rule.approved_by || [];
+                const approvedNames = approvedBy.map((u) => u.name).join(", ") || "none";
+                const status = rule.approved ? "✓ APPROVED" : "○ pending";
+                console.log(`\n     Rule: "${rule.name}"`);
+                console.log(`       Status: ${status}`);
+                console.log(`       Required: ${rule.approvals_required} approval(s)`);
+                console.log(`       Approved by: ${approvedNames} (${approvedBy.length}/${rule.approvals_required})`);
+            }
+            console.log();
+        }
+        // Test approve_merge_request
+        console.log("4. Testing approve_merge_request...");
+        const approveResponse = await sendMcpRequest(serverProcess, "tools/call", {
+            name: "approve_merge_request",
+            arguments: {
+                project_id: GITLAB_PROJECT_ID,
+                merge_request_iid: mrIid,
+            },
+        });
+        if (approveResponse.error) {
+            console.log("   ✗ Approve error:", approveResponse.error);
+        }
+        else {
+            console.log("   ✓ Approved successfully");
+        }
+        // Wait 3 seconds before unapproving
+        console.log("\n   Waiting 3 seconds...");
+        await new Promise(resolve => setTimeout(resolve, 3000));
+        // Test unapprove_merge_request
+        console.log("\n5. Testing unapprove_merge_request...");
+        const unapproveResponse = await sendMcpRequest(serverProcess, "tools/call", {
+            name: "unapprove_merge_request",
+            arguments: {
+                project_id: GITLAB_PROJECT_ID,
+                merge_request_iid: mrIid,
+            },
+        });
+        if (unapproveResponse.error) {
+            console.log("   ✗ Unapprove error:", unapproveResponse.error);
+        }
+        else {
+            console.log("   ✓ Unapproved successfully");
+        }
+        console.log("\n=== Tests Complete ===");
+    }
+    finally {
+        serverProcess.kill();
+    }
+}
+runTests().catch(error => {
+    console.error("Test failed:", error);
+    process.exit(1);
+});

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

@@ -0,0 +1,132 @@
+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 get_merge_request_diffs
+async function callGetMergeRequestDiffs(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_diffs", arguments: args }
+        }) + '\n');
+    });
+}
+describe('get_merge_request_diffs with excluded_file_patterns', () => {
+    let mockGitLab;
+    let mockGitLabUrl;
+    before(async () => {
+        const mockPort = await findMockServerPort(9100);
+        mockGitLab = new MockGitLabServer({
+            port: mockPort,
+            validTokens: [MOCK_TOKEN]
+        });
+        await mockGitLab.start();
+        mockGitLabUrl = mockGitLab.getUrl();
+    });
+    after(async () => {
+        await mockGitLab.stop();
+    });
+    test('returns all diffs without filtering', async () => {
+        const diffs = await callGetMergeRequestDiffs({ 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(diffs), 'Response should be an array');
+        assert.strictEqual(diffs.length, 4, 'Should return 4 diffs');
+        assert.strictEqual(diffs[0].new_path, 'src/index.ts');
+        assert.strictEqual(diffs[1].new_path, 'vendor/package/file.js');
+        assert.strictEqual(diffs[2].new_path, 'README.md');
+        assert.strictEqual(diffs[3].new_path, 'package-lock.json');
+    });
+    test('filters out vendor folder with ^vendor/ pattern', async () => {
+        const diffs = await callGetMergeRequestDiffs({
+            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(diffs), 'Response should be an array');
+        assert.strictEqual(diffs.length, 3, 'Should return 3 diffs (vendor filtered out)');
+        assert.strictEqual(diffs[0].new_path, 'src/index.ts');
+        assert.strictEqual(diffs[1].new_path, 'README.md');
+        assert.strictEqual(diffs[2].new_path, 'package-lock.json');
+    });
+    test('filters out package-lock.json with package-lock pattern', async () => {
+        const diffs = await callGetMergeRequestDiffs({
+            project_id: TEST_PROJECT_ID,
+            merge_request_iid: TEST_MR_IID,
+            excluded_file_patterns: ['package-lock\\.json']
+        }, {
+            GITLAB_API_URL: `${mockGitLabUrl}/api/v4`,
+            GITLAB_PERSONAL_ACCESS_TOKEN: MOCK_TOKEN
+        });
+        assert.ok(Array.isArray(diffs), 'Response should be an array');
+        assert.strictEqual(diffs.length, 3, 'Should return 3 diffs (package-lock.json filtered out)');
+        assert.strictEqual(diffs[0].new_path, 'src/index.ts');
+        assert.strictEqual(diffs[1].new_path, 'vendor/package/file.js');
+        assert.strictEqual(diffs[2].new_path, 'README.md');
+    });
+    test('filters multiple patterns at once', async () => {
+        const diffs = await callGetMergeRequestDiffs({
+            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(diffs), 'Response should be an array');
+        assert.strictEqual(diffs.length, 2, 'Should return 2 diffs (vendor and package-lock filtered out)');
+        assert.strictEqual(diffs[0].new_path, 'src/index.ts');
+        assert.strictEqual(diffs[1].new_path, 'README.md');
+    });
+});

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

@@ -327,6 +327,60 @@ export class MockGitLabServer {
                 }
             ]);
         });
+        // GET /api/v4/projects/:projectId/merge_requests/:mr_iid/changes - Get MR diffs
+        this.app.get('/api/v4/projects/:projectId/merge_requests/:mr_iid/changes', (req, res) => {
+            const mrIid = parseInt(req.params.mr_iid);
+            res.json({
+                id: mrIid,
+                iid: mrIid,
+                project_id: parseInt(req.params.projectId),
+                title: `Test MR ${mrIid}`,
+                state: 'opened',
+                created_at: '2024-01-01T00:00:00Z',
+                changes: [
+                    {
+                        old_path: 'src/index.ts',
+                        new_path: 'src/index.ts',
+                        a_mode: '100644',
+                        b_mode: '100644',
+                        diff: '@@ -1,1 +1,2 @@\n-line 1\n+line 1 modified\n+new line 2\n',
+                        new_file: false,
+                        renamed_file: false,
+                        deleted_file: false
+                    },
+                    {
+                        old_path: 'vendor/package/file.js',
+                        new_path: 'vendor/package/file.js',
+                        a_mode: '100644',
+                        b_mode: '100644',
+                        diff: '@@ -1,1 +1,1 @@\n-vendor content old\n+vendor content new\n',
+                        new_file: false,
+                        renamed_file: false,
+                        deleted_file: false
+                    },
+                    {
+                        old_path: 'README.md',
+                        new_path: 'README.md',
+                        a_mode: '100644',
+                        b_mode: '100644',
+                        diff: '@@ -1,1 +1,1 @@\n-old readme\n+new readme\n',
+                        new_file: false,
+                        renamed_file: false,
+                        deleted_file: false
+                    },
+                    {
+                        old_path: 'package-lock.json',
+                        new_path: 'package-lock.json',
+                        a_mode: '100644',
+                        b_mode: '100644',
+                        diff: '{\n- "version": "1.0.0"\n+ "version": "1.0.1"\n}\n',
+                        new_file: false,
+                        renamed_file: false,
+                        deleted_file: false
+                    }
+                ]
+            });
+        });
         // Health check endpoint
         this.app.get('/health', (req, res) => {
             res.json({ status: 'ok', message: 'Mock GitLab API is running' });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zereight/mcp-gitlab",
-  "version": "2.0.23",
+  "version": "2.0.25",
   "description": "MCP server for using the GitLab API",
   "license": "MIT",
   "author": "zereight",
@@ -29,18 +29,19 @@
     "changelog": "auto-changelog -p",
     "test": "npm run test:all",
     "test:all": "npm run build && npm run test:mock && npm run test:live",
-    "test:mock": "npx tsx --test test/remote-auth-simple-test.ts && tsx test/oauth-tests.ts && tsx test/test-list-merge-requests.ts",
-    "test:live": "node test/validate-api.js && tsx test/readonly-mcp-tests.ts",
+    "test:mock": "npx tsx --test test/remote-auth-simple-test.ts && tsx test/oauth-tests.ts && tsx test/test-list-merge-requests.ts && tsx test/test-list-project-members.ts",
+    "test:live": "node test/validate-api.js",
     "test:remote-auth": "npm run build && npx tsx --test test/remote-auth-simple-test.ts",
-    "test:mcp:readonly": "tsx test/readonly-mcp-tests.ts",
     "test:oauth": "tsx test/oauth-tests.ts",
     "test:list-merge-requests": "npm run build && tsx test/test-list-merge-requests.ts",
+    "test:approvals": "npm run build && tsx test/test-merge-request-approvals.ts",
     "lint": "eslint . --ext .ts",
     "lint:fix": "eslint . --ext .ts --fix",
     "format": "prettier --write \"**/*.{js,ts,json,md}\"",
     "format:check": "prettier --check \"**/*.{js,ts,json,md}\""
   },
   "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.24.2",
     "@types/node-fetch": "^2.6.12",
     "express": "^5.1.0",
     "fetch-cookie": "^3.1.0",
@@ -53,9 +54,9 @@
     "pino-pretty": "^13.0.0",
     "pkce-challenge": "^5.0.0",
     "socks-proxy-agent": "^8.0.5",
+    "tldts": "^6.1.86",
     "tough-cookie": "^5.1.2",
     "zod": "^3.24.2",
-    "@modelcontextprotocol/sdk": "^1.24.2",
     "zod-to-json-schema": "3.24.5"
   },
   "devDependencies": {