@zereight/mcp-gitlab 2.0.33 → 2.0.35

package/build/test/no-proxy-test.js

@@ -0,0 +1,138 @@
+/**
+ * NO_PROXY Test Suite
+ * Tests NO_PROXY pattern matching and proxy bypass functionality
+ */
+import { describe, test } from 'node:test';
+import assert from 'node:assert';
+import { GitLabClientPool } from '../gitlab-client-pool.js';
+console.log('🚫 NO_PROXY Test Suite');
+console.log('');
+describe('NO_PROXY Pattern Matching', () => {
+    test('should bypass proxy for exact hostname match', () => {
+        const pool = new GitLabClientPool({
+            httpProxy: 'http://proxy.example.com:8080',
+            httpsProxy: 'http://proxy.example.com:8080',
+            noProxy: 'gitlab.internal.com',
+        });
+        // Create agent for the NO_PROXY matched host
+        const agent = pool.getOrCreateAgentForUrl('https://gitlab.internal.com/api/v4');
+        // The agent should NOT be a proxy agent
+        // It should be a standard HTTPS agent
+        assert.ok(agent, 'Agent should be created');
+        assert.strictEqual(agent.constructor.name, 'Agent', 'Should be a standard Agent, not a proxy agent');
+    });
+    test('should use proxy for non-matching hostname', () => {
+        const pool = new GitLabClientPool({
+            httpProxy: 'http://proxy.example.com:8080',
+            httpsProxy: 'http://proxy.example.com:8080',
+            noProxy: 'gitlab.internal.com',
+        });
+        // Create agent for a host that should use proxy
+        const agent = pool.getOrCreateAgentForUrl('https://gitlab.external.com/api/v4');
+        // The agent should be a proxy agent
+        assert.ok(agent, 'Agent should be created');
+        assert.notStrictEqual(agent.constructor.name, 'Agent', 'Should be a proxy agent, not standard Agent');
+    });
+    test('should bypass proxy for domain suffix match', () => {
+        const pool = new GitLabClientPool({
+            httpProxy: 'http://proxy.example.com:8080',
+            httpsProxy: 'http://proxy.example.com:8080',
+            noProxy: '.internal.com',
+        });
+        // Test multiple subdomains
+        const agent1 = pool.getOrCreateAgentForUrl('https://gitlab.internal.com/api/v4');
+        const agent2 = pool.getOrCreateAgentForUrl('https://api.internal.com/api/v4');
+        const agent3 = pool.getOrCreateAgentForUrl('https://dev.gitlab.internal.com/api/v4');
+        assert.strictEqual(agent1.constructor.name, 'Agent', 'gitlab.internal.com should bypass proxy');
+        assert.strictEqual(agent2.constructor.name, 'Agent', 'api.internal.com should bypass proxy');
+        assert.strictEqual(agent3.constructor.name, 'Agent', 'dev.gitlab.internal.com should bypass proxy');
+    });
+    test('should bypass proxy for localhost', () => {
+        const pool = new GitLabClientPool({
+            httpProxy: 'http://proxy.example.com:8080',
+            httpsProxy: 'http://proxy.example.com:8080',
+            noProxy: 'localhost,127.0.0.1',
+        });
+        const agent1 = pool.getOrCreateAgentForUrl('http://localhost:8080/api/v4');
+        const agent2 = pool.getOrCreateAgentForUrl('http://127.0.0.1:8080/api/v4');
+        assert.strictEqual(agent1.constructor.name, 'Agent', 'localhost should bypass proxy');
+        assert.strictEqual(agent2.constructor.name, 'Agent', '127.0.0.1 should bypass proxy');
+    });
+    test('should bypass proxy for wildcard pattern', () => {
+        const pool = new GitLabClientPool({
+            httpProxy: 'http://proxy.example.com:8080',
+            httpsProxy: 'http://proxy.example.com:8080',
+            noProxy: '*',
+        });
+        const agent = pool.getOrCreateAgentForUrl('https://gitlab.com/api/v4');
+        assert.strictEqual(agent.constructor.name, 'Agent', 'Wildcard should bypass all proxies');
+    });
+    test('should handle multiple NO_PROXY patterns', () => {
+        const pool = new GitLabClientPool({
+            httpProxy: 'http://proxy.example.com:8080',
+            httpsProxy: 'http://proxy.example.com:8080',
+            noProxy: 'localhost,.internal.com,192.168.1.1',
+        });
+        const agent1 = pool.getOrCreateAgentForUrl('http://localhost/api/v4');
+        const agent2 = pool.getOrCreateAgentForUrl('https://gitlab.internal.com/api/v4');
+        const agent3 = pool.getOrCreateAgentForUrl('http://192.168.1.1/api/v4');
+        const agent4 = pool.getOrCreateAgentForUrl('https://gitlab.com/api/v4');
+        assert.strictEqual(agent1.constructor.name, 'Agent', 'localhost should bypass proxy');
+        assert.strictEqual(agent2.constructor.name, 'Agent', '.internal.com should bypass proxy');
+        assert.strictEqual(agent3.constructor.name, 'Agent', '192.168.1.1 should bypass proxy');
+        assert.notStrictEqual(agent4.constructor.name, 'Agent', 'gitlab.com should use proxy');
+    });
+    test('should handle NO_PROXY with whitespace', () => {
+        const pool = new GitLabClientPool({
+            httpProxy: 'http://proxy.example.com:8080',
+            httpsProxy: 'http://proxy.example.com:8080',
+            noProxy: ' localhost , .internal.com , 192.168.1.1 ',
+        });
+        const agent1 = pool.getOrCreateAgentForUrl('http://localhost/api/v4');
+        const agent2 = pool.getOrCreateAgentForUrl('https://gitlab.internal.com/api/v4');
+        assert.strictEqual(agent1.constructor.name, 'Agent', 'Should handle whitespace in NO_PROXY');
+        assert.strictEqual(agent2.constructor.name, 'Agent', 'Should handle whitespace in NO_PROXY');
+    });
+    test('should work without NO_PROXY set', () => {
+        const pool = new GitLabClientPool({
+            httpProxy: 'http://proxy.example.com:8080',
+            httpsProxy: 'http://proxy.example.com:8080',
+        });
+        const agent = pool.getOrCreateAgentForUrl('https://gitlab.com/api/v4');
+        // Should use proxy when NO_PROXY is not set
+        assert.notStrictEqual(agent.constructor.name, 'Agent', 'Should use proxy when NO_PROXY is not set');
+    });
+    test('should work with NO_PROXY set but empty', () => {
+        const pool = new GitLabClientPool({
+            httpProxy: 'http://proxy.example.com:8080',
+            httpsProxy: 'http://proxy.example.com:8080',
+            noProxy: '',
+        });
+        const agent = pool.getOrCreateAgentForUrl('https://gitlab.com/api/v4');
+        // Should use proxy when NO_PROXY is empty
+        assert.notStrictEqual(agent.constructor.name, 'Agent', 'Should use proxy when NO_PROXY is empty');
+    });
+    test('should handle port-specific patterns', () => {
+        const pool = new GitLabClientPool({
+            httpProxy: 'http://proxy.example.com:8080',
+            httpsProxy: 'http://proxy.example.com:8080',
+            noProxy: 'gitlab.internal.com:443',
+        });
+        const agent1 = pool.getOrCreateAgentForUrl('https://gitlab.internal.com/api/v4'); // HTTPS uses port 443 by default
+        const agent2 = pool.getOrCreateAgentForUrl('http://gitlab.internal.com/api/v4'); // HTTP uses port 80 by default
+        assert.strictEqual(agent1.constructor.name, 'Agent', 'Should bypass proxy for matching port');
+        assert.notStrictEqual(agent2.constructor.name, 'Agent', 'Should use proxy for non-matching port');
+    });
+    test('should handle case-insensitive matching', () => {
+        const pool = new GitLabClientPool({
+            httpProxy: 'http://proxy.example.com:8080',
+            httpsProxy: 'http://proxy.example.com:8080',
+            noProxy: 'GitLab.Internal.COM',
+        });
+        const agent1 = pool.getOrCreateAgentForUrl('https://gitlab.internal.com/api/v4');
+        const agent2 = pool.getOrCreateAgentForUrl('https://GITLAB.INTERNAL.COM/api/v4');
+        assert.strictEqual(agent1.constructor.name, 'Agent', 'Should match case-insensitively (lowercase)');
+        assert.strictEqual(agent2.constructor.name, 'Agent', 'Should match case-insensitively (uppercase)');
+    });
+});
+console.log('✅ NO_PROXY tests completed');

package/build/test/remote-auth-simple-test.js

@@ -9,6 +9,7 @@ import { MockGitLabServer, findMockServerPort } from './utils/mock-gitlab-server
 import { CustomHeaderClient } from './clients/custom-header-client.js';
 // Test constants
 const MOCK_TOKEN = 'glpat-mock-token-12345';
+const MOCK_JOB_TOKEN = 'glcbt-mock-job-token-9876';
 const TEST_PROJECT_ID = '123';
 // Port ranges to avoid collisions
 const MOCK_GITLAB_PORT_BASE = 9000;
@@ -32,7 +33,7 @@ describe('Remote Authorization - Basic Functionality', () => {
         const mockPort = await findMockServerPort(MOCK_GITLAB_PORT_BASE);
         mockGitLab = new MockGitLabServer({
             port: mockPort,
-            validTokens: [MOCK_TOKEN]
+            validTokens: [MOCK_TOKEN, MOCK_JOB_TOKEN],
         });
         await mockGitLab.start();
         const mockGitLabUrl = mockGitLab.getUrl();
@@ -80,6 +81,16 @@ describe('Remote Authorization - Basic Functionality', () => {
         console.log(`  ✓ Connected with Private-Token, got ${tools.tools.length} tools`);
         await client.disconnect();
     });
+    test('should connect with JOB-TOKEN header', async () => {
+        const client = new CustomHeaderClient({
+            'job-token': MOCK_JOB_TOKEN,
+        });
+        await client.connect(mcpUrl);
+        const tools = await client.listTools();
+        assert.ok(tools.tools.length > 0, 'Should have tools');
+        console.log(`  ✓ Connected with JOB-TOKEN, got ${tools.tools.length} tools`);
+        await client.disconnect();
+    });
     test('should successfully call listTools with auth', async () => {
         const client = new CustomHeaderClient({
             'authorization': `Bearer ${MOCK_TOKEN}`

package/build/test/test-geteffectiveprojectid.js

@@ -0,0 +1,245 @@
+/**
+ * Test suite for getEffectiveProjectId function
+ * Tests the behavior of project ID resolution with different environment configurations
+ */
+import { describe, test, before, after } from 'node:test';
+import assert from 'node:assert';
+import { launchServer, findAvailablePort, cleanupServers, TransportMode, HOST } from './utils/server-launcher.js';
+import { MockGitLabServer, findMockServerPort } from './utils/mock-gitlab-server.js';
+import { StreamableHTTPTestClient } from './clients/streamable-http-client.js';
+// Use the same token that will be passed via GITLAB_TOKEN_TEST environment variable
+const MOCK_TOKEN = process.env.GITLAB_TOKEN_TEST || 'glpat-mock-token-12345';
+const DEFAULT_PROJECT_ID = '123';
+const OTHER_PROJECT_ID = '456';
+// Ensure GITLAB_TOKEN_TEST is set for launchServer() validation
+if (!process.env.GITLAB_TOKEN_TEST && !process.env.GITLAB_TOKEN) {
+    process.env.GITLAB_TOKEN_TEST = MOCK_TOKEN;
+}
+if (!process.env.TEST_PROJECT_ID) {
+    process.env.TEST_PROJECT_ID = DEFAULT_PROJECT_ID;
+}
+console.log('🔍 Testing getEffectiveProjectId functionality');
+console.log('');
+describe('getEffectiveProjectId', { concurrency: 1 }, () => {
+    describe('getEffectiveProjectId - No GITLAB_ALLOWED_PROJECT_IDS', () => {
+        let mcpUrl;
+        let mockGitLab;
+        let servers = [];
+        let client;
+        before(async () => {
+            // Start mock GitLab server
+            const mockPort = await findMockServerPort(9100);
+            mockGitLab = new MockGitLabServer({
+                port: mockPort,
+                validTokens: [MOCK_TOKEN]
+            });
+            await mockGitLab.start();
+            const mockGitLabUrl = mockGitLab.getUrl();
+            // Start MCP server WITHOUT GITLAB_ALLOWED_PROJECT_IDS
+            const mcpPort = await findAvailablePort(3100);
+            const server = await launchServer({
+                mode: TransportMode.STREAMABLE_HTTP,
+                port: mcpPort,
+                timeout: 5000,
+                env: {
+                    STREAMABLE_HTTP: 'true',
+                    GITLAB_API_URL: `${mockGitLabUrl}/api/v4`,
+                    GITLAB_PROJECT_ID: DEFAULT_PROJECT_ID,
+                    GITLAB_READ_ONLY_MODE: 'true',
+                }
+            });
+            servers.push(server);
+            mcpUrl = `http://${HOST}:${mcpPort}/mcp`;
+            client = new StreamableHTTPTestClient();
+            await client.connect(mcpUrl);
+            console.log(`Mock GitLab: ${mockGitLabUrl}`);
+            console.log(`MCP Server: ${mcpUrl}`);
+            console.log(`Default Project: ${DEFAULT_PROJECT_ID}`);
+        });
+        after(async () => {
+            if (client) {
+                await client.disconnect();
+            }
+            cleanupServers(servers);
+            if (mockGitLab) {
+                await mockGitLab.stop();
+            }
+        });
+        test('should use GITLAB_PROJECT_ID when no project_id is provided', async () => {
+            // Call get_project without specifying project_id
+            const result = await client.callTool('get_project', {
+                project_id: ''
+            });
+            assert.ok(result.content, 'Should have content');
+            const content = result.content[0];
+            assert.ok('text' in content, 'Content should have text');
+            const project = JSON.parse(content.text);
+            // The mock server should receive a request for the default project
+            assert.strictEqual(project.id.toString(), DEFAULT_PROJECT_ID, 'Should use GITLAB_PROJECT_ID as default');
+            console.log(`  ✓ Used default project ${DEFAULT_PROJECT_ID} when no project_id provided`);
+        });
+        test('should prioritize passed project_id over GITLAB_PROJECT_ID', async () => {
+            // Call get_project with a different project_id
+            const result = await client.callTool('get_project', {
+                project_id: OTHER_PROJECT_ID
+            });
+            assert.ok(result.content, 'Should have content');
+            const content = result.content[0];
+            assert.ok('text' in content, 'Content should have text');
+            const project = JSON.parse(content.text);
+            // Should use the passed project_id, not GITLAB_PROJECT_ID
+            assert.strictEqual(project.id.toString(), OTHER_PROJECT_ID, 'Should use passed project_id');
+            console.log(`  ✓ Used passed project_id ${OTHER_PROJECT_ID} instead of default ${DEFAULT_PROJECT_ID}`);
+        });
+    });
+    describe('getEffectiveProjectId - With single GITLAB_ALLOWED_PROJECT_IDS', () => {
+        let mcpUrl;
+        let mockGitLab;
+        let servers = [];
+        let client;
+        before(async () => {
+            // Start mock GitLab server
+            const mockPort = await findMockServerPort(9200);
+            mockGitLab = new MockGitLabServer({
+                port: mockPort,
+                validTokens: [MOCK_TOKEN]
+            });
+            await mockGitLab.start();
+            const mockGitLabUrl = mockGitLab.getUrl();
+            // Start MCP server WITH single GITLAB_ALLOWED_PROJECT_IDS
+            const mcpPort = await findAvailablePort(3200);
+            const server = await launchServer({
+                mode: TransportMode.STREAMABLE_HTTP,
+                port: mcpPort,
+                timeout: 5000,
+                env: {
+                    STREAMABLE_HTTP: 'true',
+                    GITLAB_API_URL: `${mockGitLabUrl}/api/v4`,
+                    GITLAB_PROJECT_ID: DEFAULT_PROJECT_ID,
+                    GITLAB_ALLOWED_PROJECT_IDS: DEFAULT_PROJECT_ID,
+                    GITLAB_READ_ONLY_MODE: 'true',
+                }
+            });
+            servers.push(server);
+            mcpUrl = `http://${HOST}:${mcpPort}/mcp`;
+            client = new StreamableHTTPTestClient();
+            await client.connect(mcpUrl);
+            console.log(`Mock GitLab: ${mockGitLabUrl}`);
+            console.log(`MCP Server: ${mcpUrl}`);
+            console.log(`Allowed Project: ${DEFAULT_PROJECT_ID}`);
+        });
+        after(async () => {
+            if (client) {
+                await client.disconnect();
+            }
+            cleanupServers(servers);
+            if (mockGitLab) {
+                await mockGitLab.stop();
+            }
+        });
+        test('should use single allowed project as default', async () => {
+            const result = await client.callTool('get_project', {
+                project_id: ''
+            });
+            assert.ok(result.content, 'Should have content');
+            const content = result.content[0];
+            assert.ok('text' in content, 'Content should have text');
+            const project = JSON.parse(content.text);
+            assert.strictEqual(project.id.toString(), DEFAULT_PROJECT_ID, 'Should use allowed project as default');
+            console.log(`  ✓ Used allowed project ${DEFAULT_PROJECT_ID} as default`);
+        });
+        test('should reject access to non-allowed project', async () => {
+            try {
+                await client.callTool('get_project', {
+                    project_id: OTHER_PROJECT_ID
+                });
+                assert.fail('Should have rejected access to non-allowed project');
+            }
+            catch (error) {
+                assert.ok(error instanceof Error);
+                assert.ok(error.message.includes('Access denied'), 'Should indicate access denied');
+                console.log('  ✓ Correctly rejected access to non-allowed project');
+            }
+        });
+    });
+    describe('getEffectiveProjectId - With multiple GITLAB_ALLOWED_PROJECT_IDS', () => {
+        let mcpUrl;
+        let mockGitLab;
+        let servers = [];
+        let client;
+        before(async () => {
+            // Start mock GitLab server
+            const mockPort = await findMockServerPort(9300);
+            mockGitLab = new MockGitLabServer({
+                port: mockPort,
+                validTokens: [MOCK_TOKEN]
+            });
+            await mockGitLab.start();
+            const mockGitLabUrl = mockGitLab.getUrl();
+            // Start MCP server WITH multiple GITLAB_ALLOWED_PROJECT_IDS
+            const mcpPort = await findAvailablePort(3300);
+            const server = await launchServer({
+                mode: TransportMode.STREAMABLE_HTTP,
+                port: mcpPort,
+                timeout: 5000,
+                env: {
+                    STREAMABLE_HTTP: 'true',
+                    GITLAB_API_URL: `${mockGitLabUrl}/api/v4`,
+                    GITLAB_ALLOWED_PROJECT_IDS: `${DEFAULT_PROJECT_ID},${OTHER_PROJECT_ID}`,
+                    GITLAB_READ_ONLY_MODE: 'true',
+                }
+            });
+            servers.push(server);
+            mcpUrl = `http://${HOST}:${mcpPort}/mcp`;
+            client = new StreamableHTTPTestClient();
+            await client.connect(mcpUrl);
+            console.log(`Mock GitLab: ${mockGitLabUrl}`);
+            console.log(`MCP Server: ${mcpUrl}`);
+            console.log(`Allowed Projects: ${DEFAULT_PROJECT_ID},${OTHER_PROJECT_ID}`);
+        });
+        after(async () => {
+            if (client) {
+                await client.disconnect();
+            }
+            cleanupServers(servers);
+            if (mockGitLab) {
+                await mockGitLab.stop();
+            }
+        });
+        test('should require explicit project_id when multiple projects allowed', async () => {
+            try {
+                await client.callTool('get_project', {
+                    project_id: ''
+                });
+                assert.fail('Should have required explicit project_id');
+            }
+            catch (error) {
+                assert.ok(error instanceof Error);
+                assert.ok(error.message.includes('Please specify a project ID'), 'Should require project ID');
+                console.log('  ✓ Correctly required explicit project_id');
+            }
+        });
+        test('should allow access to first allowed project', async () => {
+            const result = await client.callTool('get_project', {
+                project_id: DEFAULT_PROJECT_ID
+            });
+            assert.ok(result.content, 'Should have content');
+            const content = result.content[0];
+            assert.ok('text' in content, 'Content should have text');
+            const project = JSON.parse(content.text);
+            assert.strictEqual(project.id.toString(), DEFAULT_PROJECT_ID, 'Should allow first project');
+            console.log(`  ✓ Allowed access to first project ${DEFAULT_PROJECT_ID}`);
+        });
+        test('should allow access to second allowed project', async () => {
+            const result = await client.callTool('get_project', {
+                project_id: OTHER_PROJECT_ID
+            });
+            assert.ok(result.content, 'Should have content');
+            const content = result.content[0];
+            assert.ok('text' in content, 'Content should have text');
+            const project = JSON.parse(content.text);
+            assert.strictEqual(project.id.toString(), OTHER_PROJECT_ID, 'Should allow second project');
+            console.log(`  ✓ Allowed access to second project ${OTHER_PROJECT_ID}`);
+        });
+    });
+}); // end wrapper describe

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');
+    });
+});