@zereight/mcp-gitlab 2.1.70 → 2.2.1

package/build/test/mcp-server-name.test.js

@@ -1,87 +0,0 @@
-import { after, describe, test } from "node:test";
-import assert from "node:assert";
-import { cleanupServers, findAvailablePort, HOST, launchServer, TransportMode, } from "./utils/server-launcher.js";
-async function rawMcpRequest(url, body, headers = {}) {
-    const response = await fetch(url, {
-        method: "POST",
-        headers: {
-            "Content-Type": "application/json",
-            Accept: "application/json, text/event-stream",
-            ...headers,
-        },
-        body: JSON.stringify(body),
-    });
-    const text = await response.text();
-    const contentType = response.headers.get("content-type") ?? "";
-    if (contentType.includes("text/event-stream")) {
-        const dataLines = text
-            .split("\n")
-            .filter(line => line.startsWith("data: "))
-            .map(line => line.slice(6));
-        return {
-            status: response.status,
-            data: dataLines.length > 0 ? JSON.parse(dataLines.at(-1)) : null,
-            text,
-        };
-    }
-    return {
-        status: response.status,
-        data: text ? JSON.parse(text) : null,
-        text,
-    };
-}
-const initializeBody = {
-    jsonrpc: "2.0",
-    id: 1,
-    method: "initialize",
-    params: {
-        protocolVersion: "2025-03-26",
-        capabilities: {},
-        clientInfo: { name: "server-name-test", version: "1.0.0" },
-    },
-};
-let portOffset = 0;
-async function launchWithServerName(mcpServerName) {
-    const port = await findAvailablePort(3700 + portOffset++ * 10);
-    const server = await launchServer({
-        mode: TransportMode.STREAMABLE_HTTP,
-        port,
-        timeout: 10_000,
-        env: {
-            STREAMABLE_HTTP: "true",
-            REMOTE_AUTHORIZATION: "true",
-            GITLAB_ALLOW_UNAUTHENTICATED_TOOL_DISCOVERY: "true",
-            GITLAB_API_URL: "https://gitlab.example.com/api/v4",
-            ...(mcpServerName !== undefined ? { MCP_SERVER_NAME: mcpServerName } : {}),
-        },
-    });
-    return { server, mcpUrl: `http://${HOST}:${port}/mcp` };
-}
-describe("MCP_SERVER_NAME", { timeout: 20_000 }, () => {
-    let servers = [];
-    after(() => {
-        cleanupServers(servers);
-        servers = [];
-    });
-    test("defaults to zereight-gitlab-mcp-server when unset", async () => {
-        const { server, mcpUrl } = await launchWithServerName();
-        servers.push(server);
-        const response = await rawMcpRequest(mcpUrl, initializeBody);
-        assert.strictEqual(response.status, 200, response.text);
-        assert.strictEqual(response.data?.result?.serverInfo?.name, "zereight-gitlab-mcp-server");
-    });
-    test("reports the overridden name when MCP_SERVER_NAME is set", async () => {
-        const { server, mcpUrl } = await launchWithServerName("gitlab-selfhosted-readonly");
-        servers.push(server);
-        const response = await rawMcpRequest(mcpUrl, initializeBody);
-        assert.strictEqual(response.status, 200, response.text);
-        assert.strictEqual(response.data?.result?.serverInfo?.name, "gitlab-selfhosted-readonly");
-    });
-    test("treats a whitespace-only MCP_SERVER_NAME as unset", async () => {
-        const { server, mcpUrl } = await launchWithServerName("   ");
-        servers.push(server);
-        const response = await rawMcpRequest(mcpUrl, initializeBody);
-        assert.strictEqual(response.status, 200, response.text);
-        assert.strictEqual(response.data?.result?.serverInfo?.name, "zereight-gitlab-mcp-server");
-    });
-});

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

@@ -1,75 +0,0 @@
-import { describe, it } from "node:test";
-import assert from "node:assert";
-import { GitLabMergeRequestSchema, MergeMergeRequestSchema } from "../schemas.js";
-const HEAD_SHA = "e82eb4a098e32c796079ca3915e07487fc4db24c";
-const PROJECT_ID = "group/project";
-const MERGE_REQUEST_IID = "42";
-function mergeArgs(overrides = {}) {
-    return {
-        project_id: PROJECT_ID,
-        merge_request_iid: MERGE_REQUEST_IID,
-        ...overrides,
-    };
-}
-function mergeRequest(overrides = {}) {
-    return {
-        id: "1001",
-        iid: MERGE_REQUEST_IID,
-        project_id: "123",
-        title: "Add milestone exposure",
-        description: "Expose MR milestone",
-        state: "opened",
-        author: {
-            id: "1",
-            username: "octocat",
-            name: "Octo Cat",
-            avatar_url: null,
-            web_url: "https://gitlab.example.com/octocat",
-        },
-        assignees: [],
-        reviewers: [],
-        source_branch: "feature/milestone",
-        target_branch: "main",
-        web_url: "https://gitlab.example.com/group/project/-/merge_requests/42",
-        created_at: "2026-05-07T00:00:00.000Z",
-        updated_at: "2026-05-07T00:00:00.000Z",
-        merged_at: null,
-        closed_at: null,
-        merge_commit_sha: null,
-        ...overrides,
-    };
-}
-describe("When parsing merge_merge_request arguments", () => {
-    describe("with sha provided", () => {
-        it("should keep sha on the parsed object", () => {
-            const parsed = MergeMergeRequestSchema.parse(mergeArgs({ sha: HEAD_SHA }));
-            assert.strictEqual(parsed.sha, HEAD_SHA);
-        });
-    });
-    describe("with sha omitted", () => {
-        it("should parse and leave sha undefined", () => {
-            const parsed = MergeMergeRequestSchema.parse(mergeArgs());
-            assert.strictEqual(parsed.sha, undefined);
-        });
-    });
-    describe("with an unknown extra field", () => {
-        it("should strip the unknown field", () => {
-            const parsed = MergeMergeRequestSchema.parse(mergeArgs({ not_a_schema_field: "drop-me" }));
-            assert.equal("not_a_schema_field" in parsed, false);
-        });
-    });
-});
-describe("When parsing a GitLab merge request response", () => {
-    describe("with sha present", () => {
-        it("should keep sha instead of stripping it", () => {
-            const parsed = GitLabMergeRequestSchema.parse(mergeRequest({ sha: HEAD_SHA }));
-            assert.strictEqual(parsed.sha, HEAD_SHA);
-        });
-    });
-    describe("with sha omitted", () => {
-        it("should accept the payload", () => {
-            const parsed = GitLabMergeRequestSchema.parse(mergeRequest());
-            assert.strictEqual(parsed.sha, undefined);
-        });
-    });
-});

package/build/test/multi-server-test.js

@@ -1,190 +0,0 @@
-import { describe, test, after, before } from 'node:test';
-import assert from 'node:assert';
-import { launchServer, findAvailablePort, TransportMode, HOST } from './utils/server-launcher.js';
-import { MockGitLabServer, findMockServerPort } from './utils/mock-gitlab-server.js';
-import { CustomHeaderClient } from './clients/custom-header-client.js';
-const MOCK_TOKEN = 'glpat-mock-token-12345';
-const project1 = {
-    id: 1,
-    name: "ProjectFromServer1",
-    description: "Mock project from server 1",
-    path_with_namespace: "group1/project1",
-    web_url: "http://mock.gitlab/group1/project1",
-    default_branch: "main",
-    visibility: "private",
-    path: "project1",
-    created_at: new Date().toISOString(),
-    namespace: {
-        id: 1,
-        name: "group1",
-        path: "group1",
-        kind: "group",
-        full_path: "group1",
-    },
-};
-const project2 = {
-    id: 2,
-    name: "ProjectFromServer2",
-    description: "Mock project from server 2",
-    path_with_namespace: "group2/project2",
-    web_url: "http://mock.gitlab/group2/project2",
-    default_branch: "main",
-    visibility: "private",
-    path: "project2",
-    created_at: new Date().toISOString(),
-    namespace: {
-        id: 2,
-        name: "group2",
-        path: "group2",
-        kind: "group",
-        full_path: "group2",
-    },
-};
-describe("Single Client Mode (ENABLE_DYNAMIC_API_URL=false)", () => {
-    let mcpServer;
-    let mcpUrl;
-    let mockServer1;
-    before(async () => {
-        const mockPort = await findMockServerPort();
-        mockServer1 = new MockGitLabServer({ port: mockPort, validTokens: [MOCK_TOKEN] });
-        mockServer1.addMockHandler('get', '/projects/1', (req, res) => { res.json(project1); });
-        await mockServer1.start();
-        const mcpPort = await findAvailablePort(3002);
-        mcpServer = await launchServer({
-            mode: TransportMode.STREAMABLE_HTTP,
-            port: mcpPort,
-            env: {
-                GITLAB_API_URL: `${mockServer1.getUrl()}/api/v4`,
-                ENABLE_DYNAMIC_API_URL: "false",
-                REMOTE_AUTHORIZATION: "true",
-            },
-        });
-        mcpUrl = `http://${HOST}:${mcpPort}/mcp`;
-    });
-    after(async () => {
-        if (mcpServer)
-            mcpServer.kill();
-        if (mockServer1)
-            await mockServer1.stop();
-    });
-    test("should use the default server when no header is provided", async () => {
-        const client = new CustomHeaderClient({ headers: { 'authorization': `Bearer ${MOCK_TOKEN}` } });
-        await client.connect(mcpUrl);
-        const result = await client.callTool('get_project', { project_id: "1" });
-        if (result.content[0].type === 'text') {
-            const textContent = JSON.parse(result.content[0].text);
-            assert.deepStrictEqual(textContent, project1);
-        }
-        else {
-            assert.fail('Expected text content from tool call');
-        }
-        await client.disconnect();
-    });
-    test("should IGNORE the custom header and still use the default server", async () => {
-        const client = new CustomHeaderClient({
-            headers: {
-                'authorization': `Bearer ${MOCK_TOKEN}`,
-                'X-GitLab-API-URL': `http://localhost:9999/api/v4`,
-            }
-        });
-        await client.connect(mcpUrl);
-        const result = await client.callTool('get_project', { project_id: "1" });
-        if (result.content[0].type === 'text') {
-            const textContent = JSON.parse(result.content[0].text);
-            assert.deepStrictEqual(textContent, project1);
-        }
-        else {
-            assert.fail('Expected text content from tool call');
-        }
-        await client.disconnect();
-    });
-});
-describe("Dynamic Client Mode (ENABLE_DYNAMIC_API_URL=true)", () => {
-    let mcpServer;
-    let mcpUrl;
-    let mockServer1;
-    let mockServer2;
-    before(async () => {
-        const port1 = await findMockServerPort();
-        const port2 = await findMockServerPort();
-        mockServer1 = new MockGitLabServer({ port: port1, validTokens: [MOCK_TOKEN] });
-        mockServer2 = new MockGitLabServer({ port: port2, validTokens: [MOCK_TOKEN] });
-        mockServer1.addMockHandler('get', '/projects/1', (req, res) => { res.json(project1); });
-        mockServer2.addMockHandler('get', '/projects/2', (req, res) => { res.json(project2); });
-        await mockServer1.start();
-        await mockServer2.start();
-        const mcpPort = await findAvailablePort(3012);
-        mcpServer = await launchServer({
-            mode: TransportMode.STREAMABLE_HTTP,
-            port: mcpPort,
-            env: {
-                GITLAB_API_URL: `${mockServer1.getUrl()}/api/v4,${mockServer2.getUrl()}/api/v4`,
-                ENABLE_DYNAMIC_API_URL: "true",
-                REMOTE_AUTHORIZATION: "true",
-            },
-        });
-        mcpUrl = `http://${HOST}:${mcpPort}/mcp`;
-    });
-    after(async () => {
-        if (mcpServer)
-            mcpServer.kill();
-        if (mockServer1)
-            await mockServer1.stop();
-        if (mockServer2)
-            await mockServer2.stop();
-    });
-    test("should use the default server (first in list) when no header is provided", async () => {
-        const client = new CustomHeaderClient({ headers: { 'authorization': `Bearer ${MOCK_TOKEN}` } });
-        await client.connect(mcpUrl);
-        const result = await client.callTool('get_project', { project_id: "1" });
-        if (result.content[0].type === 'text') {
-            const textContent = JSON.parse(result.content[0].text);
-            assert.deepStrictEqual(textContent, project1);
-        }
-        else {
-            assert.fail('Expected text content from tool call');
-        }
-        await client.disconnect();
-    });
-    test("should switch to the second server when the header is provided", async () => {
-        const client = new CustomHeaderClient({
-            headers: {
-                'authorization': `Bearer ${MOCK_TOKEN}`,
-                'X-GitLab-API-URL': `${mockServer2.getUrl()}/api/v4`,
-            }
-        });
-        await client.connect(mcpUrl);
-        const result = await client.callTool('get_project', { project_id: "2" });
-        if (result.content[0].type === 'text') {
-            const textContent = JSON.parse(result.content[0].text);
-            assert.deepStrictEqual(textContent, project2);
-        }
-        else {
-            assert.fail('Expected text content from tool call');
-        }
-        await client.disconnect();
-    });
-    test("should fail tool call when header contains a non-whitelisted URL", async () => {
-        const client = new CustomHeaderClient({
-            headers: {
-                'authorization': `Bearer ${MOCK_TOKEN}`,
-                'X-GitLab-API-URL': 'http://localhost:9999/api/v4',
-            }
-        });
-        // Connect succeeds (server accepts any valid URL format),
-        // but tool calls fail because the target server doesn't exist
-        await client.connect(mcpUrl);
-        try {
-            const result = await client.callTool('get_project', { project_id: "1" });
-            // If callTool returns (doesn't throw), check for error in response
-            const content = result.content[0];
-            assert.ok('text' in content, 'Should have text content');
-            assert.ok(content.text.includes('Error') || content.text.includes('error') || content.text.includes('ECONNREFUSED') || result.isError, 'Should return an error for unreachable server');
-        }
-        catch (err) {
-            // MCP client may throw for server-side errors (-32603)
-            assert.ok(err.message.includes('ECONNREFUSED') || err.message.includes('failed') || err.message.includes('error'), `Should contain connection error info: ${err.message}`);
-        }
-        await client.disconnect();
-    });
-});

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

@@ -1,183 +0,0 @@
-/**
- * NO_PROXY Integration Test
- * Tests NO_PROXY functionality with mock servers
- */
-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';
-// Port ranges
-const MOCK_GITLAB_PORT_BASE = 9600;
-const MCP_SERVER_PORT_BASE = 3600;
-console.log('🌐 NO_PROXY Integration Test Suite');
-console.log('');
-describe('NO_PROXY Integration Tests', () => {
-    let mcpUrl;
-    let mockGitLab;
-    let servers = [];
-    let mockGitLabUrl;
-    let mockGitLabHost;
-    before(async () => {
-        // Start mock GitLab server
-        const mockPort = await findMockServerPort();
-        mockGitLab = new MockGitLabServer({
-            port: mockPort,
-            validTokens: [MOCK_TOKEN]
-        });
-        await mockGitLab.start();
-        mockGitLabUrl = mockGitLab.getUrl();
-        // Extract the host:port part for NO_PROXY
-        const url = new URL(mockGitLabUrl);
-        mockGitLabHost = url.host; // This includes port if non-standard
-        console.log(`Mock GitLab: ${mockGitLabUrl}`);
-        console.log(`Mock GitLab Host: ${mockGitLabHost}`);
-    });
-    after(async () => {
-        cleanupServers(servers);
-        if (mockGitLab) {
-            await mockGitLab.stop();
-        }
-    });
-    test('should bypass proxy when hostname is in NO_PROXY', async () => {
-        // Start MCP server with proxy settings and NO_PROXY
-        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',
-                GITLAB_API_URL: `${mockGitLabUrl}/api/v4`,
-                // Set a fake proxy that would fail if used
-                HTTP_PROXY: 'http://nonexistent-proxy.example.com:9999',
-                HTTPS_PROXY: 'http://nonexistent-proxy.example.com:9999',
-                // Bypass proxy for our mock GitLab server
-                NO_PROXY: mockGitLabHost,
-            }
-        });
-        servers.push(server);
-        mcpUrl = `http://${HOST}:${mcpPort}/mcp`;
-        console.log(`MCP Server: ${mcpUrl}`);
-        console.log(`NO_PROXY: ${mockGitLabHost}`);
-        // Create client and make a request
-        const client = new CustomHeaderClient({
-            'authorization': `Bearer ${MOCK_TOKEN}`,
-        });
-        await client.connect(mcpUrl);
-        // This should succeed because the proxy is bypassed
-        const result = await client.callTool('list_projects', { per_page: 1 });
-        console.log('  ✓ Request succeeded with NO_PROXY bypass');
-        assert.ok(result, 'Request should succeed');
-        await client.disconnect();
-    });
-    test('should use proxy when hostname is NOT in NO_PROXY', async () => {
-        // Start MCP server with proxy settings but NO_PROXY doesn't match
-        const mcpPort = await findAvailablePort(MCP_SERVER_PORT_BASE + 1);
-        const server = await launchServer({
-            mode: TransportMode.STREAMABLE_HTTP,
-            port: mcpPort,
-            timeout: 5000,
-            env: {
-                STREAMABLE_HTTP: 'true',
-                REMOTE_AUTHORIZATION: 'true',
-                GITLAB_API_URL: `${mockGitLabUrl}/api/v4`,
-                // Set a fake proxy that would fail if used
-                HTTP_PROXY: 'http://nonexistent-proxy.example.com:9999',
-                HTTPS_PROXY: 'http://nonexistent-proxy.example.com:9999',
-                // NO_PROXY doesn't match our server
-                NO_PROXY: 'different-host.example.com,10.0.0.1',
-            }
-        });
-        servers.push(server);
-        mcpUrl = `http://${HOST}:${mcpPort}/mcp`;
-        console.log(`MCP Server: ${mcpUrl}`);
-        console.log(`NO_PROXY: different-host.example.com,10.0.0.1 (should NOT match)`);
-        // Create client and make a request
-        const client = new CustomHeaderClient({
-            'authorization': `Bearer ${MOCK_TOKEN}`,
-        });
-        await client.connect(mcpUrl);
-        // This should fail because it tries to use the nonexistent proxy
-        try {
-            await client.callTool('list_projects', { per_page: 1 });
-            assert.fail('Request should have failed due to proxy connection error');
-        }
-        catch (error) {
-            console.log('  ✓ Request failed as expected (proxy error)');
-            // Expected to fail with connection/proxy error
-            assert.ok(error, 'Should throw an error when proxy fails');
-        }
-        await client.disconnect();
-    });
-    test('should bypass proxy with wildcard NO_PROXY', async () => {
-        // Start MCP server with wildcard NO_PROXY
-        const mcpPort = await findAvailablePort(MCP_SERVER_PORT_BASE + 2);
-        const server = await launchServer({
-            mode: TransportMode.STREAMABLE_HTTP,
-            port: mcpPort,
-            timeout: 5000,
-            env: {
-                STREAMABLE_HTTP: 'true',
-                REMOTE_AUTHORIZATION: 'true',
-                GITLAB_API_URL: `${mockGitLabUrl}/api/v4`,
-                // Set a fake proxy that would fail if used
-                HTTP_PROXY: 'http://nonexistent-proxy.example.com:9999',
-                HTTPS_PROXY: 'http://nonexistent-proxy.example.com:9999',
-                // Wildcard bypasses all proxies
-                NO_PROXY: '*',
-            }
-        });
-        servers.push(server);
-        mcpUrl = `http://${HOST}:${mcpPort}/mcp`;
-        console.log(`MCP Server: ${mcpUrl}`);
-        console.log(`NO_PROXY: * (wildcard - bypasses all)`);
-        // Create client and make a request
-        const client = new CustomHeaderClient({
-            'authorization': `Bearer ${MOCK_TOKEN}`,
-        });
-        await client.connect(mcpUrl);
-        // This should succeed because wildcard bypasses all proxies
-        const result = await client.callTool('list_projects', { per_page: 1 });
-        console.log('  ✓ Request succeeded with wildcard NO_PROXY');
-        assert.ok(result, 'Request should succeed');
-        await client.disconnect();
-    });
-    test('should bypass proxy with exact IP and localhost', async () => {
-        // Start MCP server with explicit IP and localhost patterns
-        const mcpPort = await findAvailablePort(MCP_SERVER_PORT_BASE + 3);
-        const server = await launchServer({
-            mode: TransportMode.STREAMABLE_HTTP,
-            port: mcpPort,
-            timeout: 5000,
-            env: {
-                STREAMABLE_HTTP: 'true',
-                REMOTE_AUTHORIZATION: 'true',
-                GITLAB_API_URL: `${mockGitLabUrl}/api/v4`,
-                // Set a fake proxy that would fail if used
-                HTTP_PROXY: 'http://nonexistent-proxy.example.com:9999',
-                HTTPS_PROXY: 'http://nonexistent-proxy.example.com:9999',
-                // Use explicit localhost and 127.0.0.1 patterns
-                NO_PROXY: 'localhost,127.0.0.1',
-            }
-        });
-        servers.push(server);
-        mcpUrl = `http://${HOST}:${mcpPort}/mcp`;
-        console.log(`MCP Server: ${mcpUrl}`);
-        console.log(`NO_PROXY: localhost,127.0.0.1 (exact matches)`);
-        // Create client and make a request
-        const client = new CustomHeaderClient({
-            'authorization': `Bearer ${MOCK_TOKEN}`,
-        });
-        await client.connect(mcpUrl);
-        // This should succeed because 127.0.0.1 and localhost are explicitly in NO_PROXY
-        const result = await client.callTool('list_projects', { per_page: 1 });
-        console.log('  ✓ Request succeeded with exact IP/localhost NO_PROXY match');
-        assert.ok(result, 'Request should succeed');
-        await client.disconnect();
-    });
-});
-console.log('✅ NO_PROXY integration tests completed');