@zereight/mcp-gitlab 2.0.13 → 2.0.19

package/build/oauth.js

@@ -16,7 +16,7 @@ const pendingAuthRequests = new Map();
  * Check if a port is already in use
  */
 async function isPortInUse(port) {
-    return new Promise((resolve) => {
+    return new Promise(resolve => {
         const server = net.createServer();
         server.once("error", (err) => {
             if (err.code === "EADDRINUSE") {
@@ -44,9 +44,9 @@ async function requestAuthFromExistingServer(port, requestId) {
             path: `/auth-request?requestId=${requestId}`,
             method: "GET",
         };
-        const req = http.request(options, (res) => {
+        const req = http.request(options, res => {
             let data = "";
-            res.on("data", (chunk) => {
+            res.on("data", chunk => {
                 data += chunk;
             });
             res.on("end", () => {
@@ -64,7 +64,7 @@ async function requestAuthFromExistingServer(port, requestId) {
                 }
             });
         });
-        req.on("error", (error) => {
+        req.on("error", error => {
             reject(new Error(`Failed to connect to existing OAuth server: ${error.message}`));
         });
         req.setTimeout(5 * 60 * 1000, () => {
@@ -82,8 +82,7 @@ export class GitLabOAuth {
     constructor(config) {
         this.config = config;
         this.tokenStoragePath =
-            config.tokenStoragePath ||
-                path.join(process.env.HOME || "", ".gitlab-mcp-token.json");
+            config.tokenStoragePath || path.join(process.env.HOME || "", ".gitlab-mcp-token.json");
     }
     /**
      * Get the authorization URL for OAuth flow
@@ -119,6 +118,10 @@ export class GitLabOAuth {
             redirect_uri: this.config.redirectUri,
             code_verifier: this.codeVerifier,
         });
+        // Add client_secret for Confidential applications
+        if (this.config.clientSecret) {
+            params.append("client_secret", this.config.clientSecret);
+        }
         const response = await fetch(tokenUrl, {
             method: "POST",
             headers: {
@@ -130,7 +133,7 @@ export class GitLabOAuth {
             const errorText = await response.text();
             throw new Error(`Token exchange failed: ${response.status} ${errorText}`);
         }
-        const data = await response.json();
+        const data = (await response.json());
         return {
             access_token: data.access_token,
             refresh_token: data.refresh_token,
@@ -150,6 +153,10 @@ export class GitLabOAuth {
             grant_type: "refresh_token",
             redirect_uri: this.config.redirectUri,
         });
+        // Add client_secret for Confidential applications
+        if (this.config.clientSecret) {
+            params.append("client_secret", this.config.clientSecret);
+        }
         const response = await fetch(tokenUrl, {
             method: "POST",
             headers: {
@@ -161,7 +168,7 @@ export class GitLabOAuth {
             const errorText = await response.text();
             throw new Error(`Token refresh failed: ${response.status} ${errorText}`);
         }
-        const data = await response.json();
+        const data = (await response.json());
         return {
             access_token: data.access_token,
             refresh_token: data.refresh_token || refreshToken,
@@ -271,7 +278,7 @@ export class GitLabOAuth {
                         const authUrl = await this.getAuthorizationUrl(newState);
                         logger.info("Opening browser for new authentication request...");
                         logger.info(`If browser doesn't open, visit: ${authUrl}`);
-                        open(authUrl).catch((err) => {
+                        open(authUrl).catch(err => {
                             logger.error("Failed to open browser:", err);
                             logger.info(`Please manually open: ${authUrl}`);
                         });
@@ -427,12 +434,12 @@ export class GitLabOAuth {
                 const authUrl = await this.getAuthorizationUrl(state);
                 logger.info("Opening browser for authentication...");
                 logger.info(`If browser doesn't open, visit: ${authUrl}`);
-                open(authUrl).catch((err) => {
+                open(authUrl).catch(err => {
                     logger.error("Failed to open browser:", err);
                     logger.info(`Please manually open: ${authUrl}`);
                 });
             });
-            server.on("error", (error) => {
+            server.on("error", error => {
                 logger.error("OAuth server error:", error);
                 const pending = pendingAuthRequests.get(initialRequestId);
                 if (pending) {
@@ -502,6 +509,7 @@ export class GitLabOAuth {
  */
 export async function initializeOAuth(gitlabUrl = "https://gitlab.com") {
     const clientId = process.env.GITLAB_OAUTH_CLIENT_ID;
+    const clientSecret = process.env.GITLAB_OAUTH_CLIENT_SECRET;
     const redirectUri = process.env.GITLAB_OAUTH_REDIRECT_URI || "http://127.0.0.1:8888/callback";
     const tokenStoragePath = process.env.GITLAB_OAUTH_TOKEN_PATH;
     if (!clientId) {
@@ -509,6 +517,7 @@ export async function initializeOAuth(gitlabUrl = "https://gitlab.com") {
     }
     const oauth = new GitLabOAuth({
         clientId,
+        clientSecret,
         redirectUri,
         gitlabUrl,
         scopes: ["api"],

package/build/test/client-pool-test.js

@@ -0,0 +1,109 @@
+/**
+ * Client Pool Test Suite
+ * Tests connection pooling limits and functionality
+ */
+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';
+// Test constants
+const MOCK_TOKEN = 'glpat-mock-token-12345';
+const POOL_MAX_SIZE = 2;
+// Port ranges
+const MOCK_GITLAB_PORT_BASE = 9500;
+const MCP_SERVER_PORT_BASE = 3500;
+console.log('🏊 Client Pool Test Suite');
+console.log('');
+describe('Client Pool Limits', () => {
+    let mcpUrl;
+    let mockGitLab;
+    let servers = [];
+    let mockGitLabUrl;
+    before(async () => {
+        // Start mock GitLab server
+        const mockPort = await findMockServerPort(MOCK_GITLAB_PORT_BASE);
+        mockGitLab = new MockGitLabServer({
+            port: mockPort,
+            validTokens: [MOCK_TOKEN]
+        });
+        await mockGitLab.start();
+        mockGitLabUrl = mockGitLab.getUrl();
+        // Start MCP server with pool limit
+        const mcpPort = await findAvailablePort(MCP_SERVER_PORT_BASE);
+        const server = await launchServer({
+            mode: TransportMode.STREAMABLE_HTTP,
+            port: mcpPort,
+            timeout: 5000,
+            env: {
+                STREAMABLE_HTTP: 'true',
+                REMOTE_AUTHORIZATION: 'true',
+                ENABLE_DYNAMIC_API_URL: 'true', // Enable dynamic URLs to test pooling
+                GITLAB_API_URL: `${mockGitLabUrl}/api/v4`,
+                GITLAB_POOL_MAX_SIZE: String(POOL_MAX_SIZE),
+            }
+        });
+        servers.push(server);
+        mcpUrl = `http://${HOST}:${mcpPort}/mcp`;
+        console.log(`Mock GitLab: ${mockGitLabUrl}`);
+        console.log(`MCP Server: ${mcpUrl}`);
+        console.log(`Pool Max Size: ${POOL_MAX_SIZE}`);
+    });
+    after(async () => {
+        cleanupServers(servers);
+        if (mockGitLab) {
+            await mockGitLab.stop();
+        }
+    });
+    test('should enforce pool size limit', async () => {
+        // The pool size is configured to 2.
+        // We will connect with 3 distinct URLs.
+        // The first 2 should succeed (or fail with network error), adding to the pool.
+        // The 3rd should fail with "Pool is full".
+        // URL 1: 127.0.0.1 (Real mock server)
+        const url1 = `${mockGitLabUrl}/api/v4`;
+        const client1 = new CustomHeaderClient({
+            'authorization': `Bearer ${MOCK_TOKEN}`,
+            'x-gitlab-api-url': url1
+        });
+        await client1.connect(mcpUrl);
+        await client1.callTool('list_projects', { per_page: 1 });
+        console.log('  ✓ Request 1 (127.0.0.1) succeeded');
+        await client1.disconnect();
+        // URL 2: localhost (Real mock server, distinct string)
+        const url2 = url1.replace('127.0.0.1', 'localhost');
+        const client2 = new CustomHeaderClient({
+            'authorization': `Bearer ${MOCK_TOKEN}`,
+            'x-gitlab-api-url': url2
+        });
+        await client2.connect(mcpUrl);
+        try {
+            await client2.callTool('list_projects', { per_page: 1 });
+            console.log('  ✓ Request 2 (localhost) succeeded');
+        }
+        catch (e) {
+            // It might fail if localhost isn't listening or something, but it shouldn't be pool full
+            console.log('  ! Request 2 failed:', e);
+            if (String(e).includes('capacity reached')) {
+                assert.fail('Request 2 failed with pool limit error prematurely');
+            }
+        }
+        await client2.disconnect();
+        // URL 3: gitlab-3.example.com (Fake, distinct string)
+        // This should trigger the pool limit check
+        const client3 = new CustomHeaderClient({
+            'authorization': `Bearer ${MOCK_TOKEN}`,
+            'x-gitlab-api-url': 'https://gitlab-3.example.com/api/v4'
+        });
+        await client3.connect(mcpUrl);
+        try {
+            await client3.callTool('list_projects', { per_page: 1 });
+            assert.fail('Request 3 should have failed with pool limit error');
+        }
+        catch (error) {
+            console.log('  ℹ️  Error received:', error.message);
+            assert.ok(error.message.includes('capacity reached') || error.message.includes('pool is full'), 'Error should be about server capacity');
+        }
+        await client3.disconnect();
+    });
+});

package/build/test/dynamic-api-url-test.js

@@ -0,0 +1,304 @@
+/**
+ * Dynamic GitLab API URL Test Suite
+ * Tests the ability to connect to multiple GitLab instances via custom headers
+ */
+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';
+// Test constants
+const MOCK_TOKEN_1 = 'glpat-mock-token-instance-1';
+const MOCK_TOKEN_2 = 'glpat-mock-token-instance-2';
+// Port ranges
+const MOCK_GITLAB_PORT_BASE_1 = 9100;
+const MOCK_GITLAB_PORT_BASE_2 = 9200;
+const MCP_SERVER_PORT_BASE = 3100;
+console.log('🌐 Dynamic GitLab API URL Test Suite');
+console.log('');
+describe('Dynamic API URL - Multiple GitLab Instances', () => {
+    let mcpUrl;
+    let mockGitLab1;
+    let mockGitLab2;
+    let mockGitLabUrl1;
+    let mockGitLabUrl2;
+    let servers = [];
+    before(async () => {
+        // Start first mock GitLab server
+        const mockPort1 = await findMockServerPort(MOCK_GITLAB_PORT_BASE_1);
+        mockGitLab1 = new MockGitLabServer({
+            port: mockPort1,
+            validTokens: [MOCK_TOKEN_1]
+        });
+        await mockGitLab1.start();
+        mockGitLabUrl1 = mockGitLab1.getUrl();
+        // Start second mock GitLab server
+        const mockPort2 = await findMockServerPort(MOCK_GITLAB_PORT_BASE_2);
+        mockGitLab2 = new MockGitLabServer({
+            port: mockPort2,
+            validTokens: [MOCK_TOKEN_2]
+        });
+        await mockGitLab2.start();
+        mockGitLabUrl2 = mockGitLab2.getUrl();
+        // Start MCP server with dynamic API URL enabled
+        const mcpPort = await findAvailablePort(MCP_SERVER_PORT_BASE);
+        const server = await launchServer({
+            mode: TransportMode.STREAMABLE_HTTP,
+            port: mcpPort,
+            timeout: 5000,
+            env: {
+                STREAMABLE_HTTP: 'true',
+                REMOTE_AUTHORIZATION: 'true',
+                ENABLE_DYNAMIC_API_URL: 'true',
+                GITLAB_READ_ONLY_MODE: 'true',
+            }
+        });
+        servers.push(server);
+        mcpUrl = `http://${HOST}:${mcpPort}/mcp`;
+        console.log(`Mock GitLab Instance 1: ${mockGitLabUrl1}`);
+        console.log(`Mock GitLab Instance 2: ${mockGitLabUrl2}`);
+        console.log(`MCP Server: ${mcpUrl}`);
+    });
+    after(async () => {
+        cleanupServers(servers);
+        if (mockGitLab1) {
+            await mockGitLab1.stop();
+        }
+        if (mockGitLab2) {
+            await mockGitLab2.stop();
+        }
+    });
+    test('should connect to first GitLab instance with custom API URL', async () => {
+        const client = new CustomHeaderClient({
+            'authorization': `Bearer ${MOCK_TOKEN_1}`,
+            'x-gitlab-api-url': mockGitLabUrl1
+        });
+        await client.connect(mcpUrl);
+        const tools = await client.listTools();
+        assert.ok(tools.tools.length > 0, 'Should have tools');
+        console.log(`  ✓ Connected to instance 1, got ${tools.tools.length} tools`);
+        await client.disconnect();
+    });
+    test('should connect to second GitLab instance with different API URL', async () => {
+        const client = new CustomHeaderClient({
+            'authorization': `Bearer ${MOCK_TOKEN_2}`,
+            'x-gitlab-api-url': mockGitLabUrl2
+        });
+        await client.connect(mcpUrl);
+        const tools = await client.listTools();
+        assert.ok(tools.tools.length > 0, 'Should have tools');
+        console.log(`  ✓ Connected to instance 2, got ${tools.tools.length} tools`);
+        await client.disconnect();
+    });
+    test('should handle multiple concurrent connections to different instances', async () => {
+        const client1 = new CustomHeaderClient({
+            'authorization': `Bearer ${MOCK_TOKEN_1}`,
+            'x-gitlab-api-url': mockGitLabUrl1
+        });
+        const client2 = new CustomHeaderClient({
+            'authorization': `Bearer ${MOCK_TOKEN_2}`,
+            'x-gitlab-api-url': mockGitLabUrl2
+        });
+        // Connect both clients
+        await Promise.all([
+            client1.connect(mcpUrl),
+            client2.connect(mcpUrl)
+        ]);
+        // List tools from both
+        const [tools1, tools2] = await Promise.all([
+            client1.listTools(),
+            client2.listTools()
+        ]);
+        assert.ok(tools1.tools.length > 0, 'Instance 1 should have tools');
+        assert.ok(tools2.tools.length > 0, 'Instance 2 should have tools');
+        console.log('  ✓ Both instances accessible concurrently');
+        // Disconnect both
+        await Promise.all([
+            client1.disconnect(),
+            client2.disconnect()
+        ]);
+    });
+    test('should reject invalid API URL format', async () => {
+        const client = new CustomHeaderClient({
+            'authorization': `Bearer ${MOCK_TOKEN_1}`,
+            'x-gitlab-api-url': 'not-a-valid-url'
+        });
+        try {
+            await client.connect(mcpUrl);
+            await client.listTools();
+            await client.disconnect();
+            assert.fail('Should have rejected invalid URL');
+        }
+        catch (error) {
+            assert.ok(error instanceof Error);
+            console.log('  ✓ Correctly rejected invalid URL format');
+        }
+    });
+    test('should reject connection with wrong token for instance', async () => {
+        const client = new CustomHeaderClient({
+            'authorization': `Bearer ${MOCK_TOKEN_1}`, // Token for instance 1
+            'x-gitlab-api-url': mockGitLabUrl2 // But connecting to instance 2
+        });
+        try {
+            await client.connect(mcpUrl);
+            await client.listTools();
+            await client.disconnect();
+            assert.fail('Should have rejected wrong token');
+        }
+        catch (error) {
+            assert.ok(error instanceof Error);
+            console.log('  ✓ Correctly rejected wrong token for instance');
+        }
+    });
+    test('should maintain separate sessions for different API URLs', async () => {
+        const client1 = new CustomHeaderClient({
+            'authorization': `Bearer ${MOCK_TOKEN_1}`,
+            'x-gitlab-api-url': mockGitLabUrl1
+        });
+        const client2 = new CustomHeaderClient({
+            'authorization': `Bearer ${MOCK_TOKEN_2}`,
+            'x-gitlab-api-url': mockGitLabUrl2
+        });
+        // Connect both
+        await client1.connect(mcpUrl);
+        await client2.connect(mcpUrl);
+        // Get session IDs
+        const sessionId1 = client1.getSessionId();
+        const sessionId2 = client2.getSessionId();
+        assert.ok(sessionId1, 'Session 1 should exist');
+        assert.ok(sessionId2, 'Session 2 should exist');
+        assert.notStrictEqual(sessionId1, sessionId2, 'Sessions should be different');
+        console.log('  ✓ Separate sessions maintained for different instances');
+        // Make requests from both sessions
+        const [tools1, tools2] = await Promise.all([
+            client1.listTools(),
+            client2.listTools()
+        ]);
+        assert.ok(tools1.tools.length > 0, 'Instance 1 should work');
+        assert.ok(tools2.tools.length > 0, 'Instance 2 should work');
+        console.log('  ✓ Both sessions work independently');
+        await client1.disconnect();
+        await client2.disconnect();
+    });
+    test('should normalize API URLs correctly', async () => {
+        // Test with URL that needs normalization (no /api/v4)
+        const client = new CustomHeaderClient({
+            'authorization': `Bearer ${MOCK_TOKEN_1}`,
+            'x-gitlab-api-url': mockGitLabUrl1 // Without /api/v4
+        });
+        await client.connect(mcpUrl);
+        const tools = await client.listTools();
+        assert.ok(tools.tools.length > 0, 'Should work with normalized URL');
+        console.log('  ✓ URL normalization works correctly');
+        await client.disconnect();
+    });
+});
+describe('Dynamic API URL - Connection Pool', () => {
+    let mcpUrl;
+    let metricsUrl;
+    let mockGitLab1;
+    let mockGitLab2;
+    let mockGitLabUrl1;
+    let mockGitLabUrl2;
+    let servers = [];
+    before(async () => {
+        // Start mock GitLab servers
+        const mockPort1 = await findMockServerPort(MOCK_GITLAB_PORT_BASE_1 + 50);
+        mockGitLab1 = new MockGitLabServer({
+            port: mockPort1,
+            validTokens: [MOCK_TOKEN_1]
+        });
+        await mockGitLab1.start();
+        mockGitLabUrl1 = mockGitLab1.getUrl();
+        const mockPort2 = await findMockServerPort(MOCK_GITLAB_PORT_BASE_2 + 50);
+        mockGitLab2 = new MockGitLabServer({
+            port: mockPort2,
+            validTokens: [MOCK_TOKEN_2]
+        });
+        await mockGitLab2.start();
+        mockGitLabUrl2 = mockGitLab2.getUrl();
+        // Start MCP server
+        const mcpPort = await findAvailablePort(MCP_SERVER_PORT_BASE + 50);
+        const server = await launchServer({
+            mode: TransportMode.STREAMABLE_HTTP,
+            port: mcpPort,
+            timeout: 5000,
+            env: {
+                STREAMABLE_HTTP: 'true',
+                REMOTE_AUTHORIZATION: 'true',
+                ENABLE_DYNAMIC_API_URL: 'true',
+                GITLAB_CLIENT_POOL_SIZE: '5',
+                GITLAB_CLIENT_IDLE_TIMEOUT: '30000',
+            }
+        });
+        servers.push(server);
+        mcpUrl = `http://${HOST}:${mcpPort}/mcp`;
+        metricsUrl = `http://${HOST}:${mcpPort}/metrics`;
+        console.log(`MCP Server: ${mcpUrl}`);
+        console.log(`Metrics URL: ${metricsUrl}`);
+    });
+    after(async () => {
+        cleanupServers(servers);
+        if (mockGitLab1) {
+            await mockGitLab1.stop();
+        }
+        if (mockGitLab2) {
+            await mockGitLab2.stop();
+        }
+    });
+    test('should track pool statistics via metrics endpoint', async () => {
+        // Make some connections first
+        const client1 = new CustomHeaderClient({
+            'authorization': `Bearer ${MOCK_TOKEN_1}`,
+            'x-gitlab-api-url': mockGitLabUrl1
+        });
+        const client2 = new CustomHeaderClient({
+            'authorization': `Bearer ${MOCK_TOKEN_2}`,
+            'x-gitlab-api-url': mockGitLabUrl2
+        });
+        await client1.connect(mcpUrl);
+        await client2.connect(mcpUrl);
+        await client1.listTools();
+        await client2.listTools();
+        // Check metrics
+        const response = await fetch(metricsUrl);
+        assert.ok(response.ok, 'Metrics endpoint should be accessible');
+        const metrics = await response.json();
+        assert.ok(metrics.gitlabClientPool, 'Should have pool metrics');
+        assert.ok(typeof metrics.gitlabClientPool.size === 'number', 'Should have pool size');
+        assert.ok(typeof metrics.gitlabClientPool.maxSize === 'number', 'Should have max size');
+        console.log('  ✓ Pool metrics available');
+        console.log(`  ℹ️  Pool size: ${metrics.gitlabClientPool.size}/${metrics.gitlabClientPool.maxSize}`);
+        await client1.disconnect();
+        await client2.disconnect();
+    });
+    test('should reuse connections for same API URL', async () => {
+        // Get initial metrics
+        const response1 = await fetch(metricsUrl);
+        const metrics1 = await response1.json();
+        const initialSize = metrics1.gitlabClientPool?.size || 0;
+        // Create multiple clients to same instance
+        const clients = [];
+        for (let i = 0; i < 3; i++) {
+            const client = new CustomHeaderClient({
+                'authorization': `Bearer ${MOCK_TOKEN_1}`,
+                'x-gitlab-api-url': mockGitLabUrl1
+            });
+            await client.connect(mcpUrl);
+            await client.listTools();
+            clients.push(client);
+        }
+        // Check metrics - should not have created 3 new pool entries
+        const response2 = await fetch(metricsUrl);
+        const metrics2 = await response2.json();
+        const finalSize = metrics2.gitlabClientPool?.size || 0;
+        // Pool size should increase by at most 1 (for the shared URL)
+        assert.ok(finalSize - initialSize <= 1, 'Should reuse connection for same URL');
+        console.log('  ✓ Connection reuse working');
+        console.log(`  ℹ️  Pool size change: ${initialSize} → ${finalSize}`);
+        // Cleanup
+        for (const client of clients) {
+            await client.disconnect();
+        }
+    });
+});