@zereight/mcp-gitlab 2.1.70 → 2.2.1

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

@@ -1,109 +0,0 @@
-/**
- * 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();
-        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/clients/client.js

@@ -1,34 +0,0 @@
-/**
- * MCP Client Interface and error classes for testing
- */
-/**
- * Base error class for MCP client errors
- */
-export class MCPClientError extends Error {
-    cause;
-    constructor(message, cause) {
-        super(message);
-        this.cause = cause;
-        this.name = 'MCPClientError';
-    }
-}
-/**
- * Connection error for MCP clients
- */
-export class MCPConnectionError extends MCPClientError {
-    constructor(message, cause) {
-        super(message, cause);
-        this.name = 'MCPConnectionError';
-    }
-}
-/**
- * Tool call error for MCP clients
- */
-export class MCPToolCallError extends MCPClientError {
-    toolName;
-    constructor(message, toolName, cause) {
-        super(message, cause);
-        this.toolName = toolName;
-        this.name = 'MCPToolCallError';
-    }
-}

package/build/test/clients/custom-header-client.js

@@ -1,122 +0,0 @@
-/**
- * Custom Header MCP Client for Testing Remote Authorization
- * Extends StreamableHTTPTestClient to support custom headers
- */
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
-/**
- * MCP client with support for custom HTTP headers
- * Useful for testing remote authorization scenarios
- */
-export class CustomHeaderClient {
-    client;
-    transport = null;
-    customHeaders;
-    timeout;
-    constructor(options = {}) {
-        // Support both old signature (headers only) and new options object
-        if ('headers' in options || 'timeout' in options || 'clientName' in options) {
-            const opts = options;
-            this.customHeaders = opts.headers || {};
-            this.timeout = opts.timeout || 30000;
-            this.client = new Client({
-                name: opts.clientName || "test-client-with-headers",
-                version: opts.clientVersion || "1.0.0"
-            });
-        }
-        else {
-            // Backward compatible: treat options as headers record
-            this.customHeaders = options;
-            this.timeout = 30000;
-            this.client = new Client({ name: "test-client-with-headers", version: "1.0.0" });
-        }
-    }
-    /**
-     * Connect to MCP server with custom headers
-     */
-    async connect(url) {
-        if (this.transport) {
-            throw new Error('Client is already connected');
-        }
-        try {
-            this.transport = new StreamableHTTPClientTransport(new URL(url), {
-                requestInit: {
-                    headers: this.customHeaders
-                }
-            });
-            await this.client.connect(this.transport);
-        }
-        catch (error) {
-            this.transport = null;
-            throw new Error(`Failed to connect: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    /**
-     * Disconnect from server
-     */
-    async disconnect() {
-        if (this.transport) {
-            try {
-                await this.transport.close();
-            }
-            catch (error) {
-                // Silently ignore disconnect errors in tests
-                // In production, you'd want proper logging
-            }
-            finally {
-                this.transport = null;
-            }
-        }
-    }
-    /**
-     * Get session ID from transport (useful for testing)
-     */
-    getSessionId() {
-        return this.transport?.sessionId;
-    }
-    /**
-     * Update custom headers (creates new connection if already connected)
-     */
-    setHeaders(headers) {
-        if (this.transport) {
-            throw new Error('Cannot update headers while connected. Disconnect first.');
-        }
-        this.customHeaders = headers;
-    }
-    /**
-     * List available tools from server
-     */
-    async listTools() {
-        if (!this.transport) {
-            throw new Error('Client is not connected');
-        }
-        try {
-            const response = await this.client.listTools();
-            return response;
-        }
-        catch (error) {
-            throw new Error(`Failed to list tools: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    /**
-     * Call a tool on the server
-     */
-    async callTool(name, arguments_ = {}) {
-        if (!this.transport) {
-            throw new Error('Client is not connected');
-        }
-        try {
-            const response = await this.client.callTool({ name, arguments: arguments_ });
-            return response;
-        }
-        catch (error) {
-            throw new Error(`Failed to call tool '${name}': ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    /**
-     * Get client connection status
-     */
-    get isConnected() {
-        return this.transport !== null;
-    }
-}

package/build/test/clients/sse-client.js

@@ -1,95 +0,0 @@
-/**
- * SSE MCP Client for testing
- */
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
-import { MCPConnectionError, MCPToolCallError } from "./client.js";
-export class SSETestClient {
-    client;
-    transport = null;
-    constructor() {
-        this.client = new Client({ name: "test-client", version: "1.0.0" });
-    }
-    /**
-     * Connect to MCP server via SSE
-     */
-    async connect(url) {
-        if (this.transport) {
-            throw new MCPConnectionError('Client is already connected');
-        }
-        try {
-            this.transport = new SSEClientTransport(new URL(url));
-            await this.client.connect(this.transport);
-        }
-        catch (error) {
-            this.transport = null;
-            throw new MCPConnectionError(`Failed to connect to SSE server: ${error instanceof Error ? error.message : String(error)}`, error instanceof Error ? error : undefined);
-        }
-    }
-    /**
-     * Disconnect from server
-     */
-    async disconnect() {
-        if (this.transport) {
-            try {
-                await this.transport.close();
-            }
-            catch (error) {
-                // Log but don't throw on disconnect errors
-                console.warn('Warning during disconnect:', error);
-            }
-            finally {
-                this.transport = null;
-            }
-        }
-    }
-    /**
-     * List available tools from server
-     */
-    async listTools() {
-        if (!this.transport) {
-            throw new MCPConnectionError('Client is not connected');
-        }
-        try {
-            const response = await this.client.listTools();
-            return response;
-        }
-        catch (error) {
-            throw new MCPToolCallError(`Failed to list tools: ${error instanceof Error ? error.message : String(error)}`, 'listTools', error instanceof Error ? error : undefined);
-        }
-    }
-    /**
-     * Call a tool on the server
-     */
-    async callTool(name, arguments_ = {}) {
-        if (!this.transport) {
-            throw new MCPConnectionError('Client is not connected');
-        }
-        try {
-            const response = await this.client.callTool({ name, arguments: arguments_ });
-            // Ensure the response conforms to CallToolResult interface
-            return response;
-        }
-        catch (error) {
-            throw new MCPToolCallError(`Failed to call tool '${name}': ${error instanceof Error ? error.message : String(error)}`, name, error instanceof Error ? error : undefined);
-        }
-    }
-    /**
-     * Test connection by listing tools
-     */
-    async testConnection() {
-        try {
-            const tools = await this.listTools();
-            return Array.isArray(tools.tools) && tools.tools.length > 0;
-        }
-        catch (error) {
-            return false;
-        }
-    }
-    /**
-     * Get client connection status
-     */
-    get isConnected() {
-        return this.transport !== null;
-    }
-}

package/build/test/clients/stdio-client.js

@@ -1,113 +0,0 @@
-/**
- * Stdio MCP Client for testing
- */
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
-import { MCPConnectionError, MCPToolCallError } from "./client.js";
-export class StdioTestClient {
-    client;
-    transport = null;
-    constructor() {
-        this.client = new Client({ name: "test-client", version: "1.0.0" });
-    }
-    /**
-     * Connect to MCP server via stdio
-     */
-    async connect(serverPath, env) {
-        if (this.transport) {
-            throw new MCPConnectionError('Client is already connected');
-        }
-        try {
-            const command = process.execPath;
-            const args = [serverPath];
-            // Prepare environment variables for the server process
-            const serverEnv = {};
-            // Copy process.env, filtering out undefined values
-            for (const [key, value] of Object.entries(process.env)) {
-                if (value !== undefined) {
-                    serverEnv[key] = value;
-                }
-            }
-            // Add custom environment variables
-            if (env) {
-                Object.assign(serverEnv, env);
-            }
-            this.transport = new StdioClientTransport({
-                command,
-                args,
-                env: serverEnv
-            });
-            await this.client.connect(this.transport);
-        }
-        catch (error) {
-            this.transport = null;
-            throw new MCPConnectionError(`Failed to connect to stdio server: ${error instanceof Error ? error.message : String(error)}`, error instanceof Error ? error : undefined);
-        }
-    }
-    /**
-     * Disconnect from server
-     */
-    async disconnect() {
-        if (this.transport) {
-            try {
-                await this.transport.close();
-            }
-            catch (error) {
-                // Log but don't throw on disconnect errors
-                console.warn('Warning during disconnect:', error);
-            }
-            finally {
-                this.transport = null;
-            }
-        }
-    }
-    /**
-     * List available tools from server
-     */
-    async listTools() {
-        if (!this.transport) {
-            throw new MCPConnectionError('Client is not connected');
-        }
-        try {
-            const response = await this.client.listTools();
-            return response;
-        }
-        catch (error) {
-            throw new MCPToolCallError(`Failed to list tools: ${error instanceof Error ? error.message : String(error)}`, 'listTools', error instanceof Error ? error : undefined);
-        }
-    }
-    /**
-     * Call a tool on the server
-     */
-    async callTool(name, arguments_ = {}) {
-        if (!this.transport) {
-            throw new MCPConnectionError('Client is not connected');
-        }
-        try {
-            const response = await this.client.callTool({ name, arguments: arguments_ });
-            // Ensure the response conforms to CallToolResult interface
-            return response;
-        }
-        catch (error) {
-            throw new MCPToolCallError(`Failed to call tool '${name}': ${error instanceof Error ? error.message : String(error)}`, name, error instanceof Error ? error : undefined);
-        }
-    }
-    /**
-     * Test connection by listing tools
-     */
-    async testConnection() {
-        try {
-            const tools = await this.listTools();
-            return Array.isArray(tools.tools) && tools.tools.length > 0;
-        }
-        catch (error) {
-            return false;
-        }
-    }
-    /**
-     * Get client connection status
-     */
-    get isConnected() {
-        return this.transport !== null;
-    }
-}

package/build/test/clients/streamable-http-client.js

@@ -1,95 +0,0 @@
-/**
- * Streamable HTTP MCP Client for testing
- */
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
-import { MCPConnectionError, MCPToolCallError } from "./client.js";
-export class StreamableHTTPTestClient {
-    client;
-    transport = null;
-    constructor() {
-        this.client = new Client({ name: "test-client", version: "1.0.0" });
-    }
-    /**
-     * Connect to MCP server via Streamable HTTP
-     */
-    async connect(url) {
-        if (this.transport) {
-            throw new MCPConnectionError('Client is already connected');
-        }
-        try {
-            this.transport = new StreamableHTTPClientTransport(new URL(url));
-            await this.client.connect(this.transport);
-        }
-        catch (error) {
-            this.transport = null;
-            throw new MCPConnectionError(`Failed to connect to Streamable HTTP server: ${error instanceof Error ? error.message : String(error)}`, error instanceof Error ? error : undefined);
-        }
-    }
-    /**
-     * Disconnect from server
-     */
-    async disconnect() {
-        if (this.transport) {
-            try {
-                await this.transport.close();
-            }
-            catch (error) {
-                // Log but don't throw on disconnect errors
-                console.warn('Warning during disconnect:', error);
-            }
-            finally {
-                this.transport = null;
-            }
-        }
-    }
-    /**
-     * List available tools from server
-     */
-    async listTools() {
-        if (!this.transport) {
-            throw new MCPConnectionError('Client is not connected');
-        }
-        try {
-            const response = await this.client.listTools();
-            return response;
-        }
-        catch (error) {
-            throw new MCPToolCallError(`Failed to list tools: ${error instanceof Error ? error.message : String(error)}`, 'listTools', error instanceof Error ? error : undefined);
-        }
-    }
-    /**
-     * Call a tool on the server
-     */
-    async callTool(name, arguments_ = {}) {
-        if (!this.transport) {
-            throw new MCPConnectionError('Client is not connected');
-        }
-        try {
-            const response = await this.client.callTool({ name, arguments: arguments_ });
-            // Ensure the response conforms to CallToolResult interface
-            return response;
-        }
-        catch (error) {
-            throw new MCPToolCallError(`Failed to call tool '${name}': ${error instanceof Error ? error.message : String(error)}`, name, error instanceof Error ? error : undefined);
-        }
-    }
-    /**
-     * Test connection by listing tools
-     */
-    async testConnection() {
-        try {
-            const tools = await this.listTools();
-            return Array.isArray(tools.tools) && tools.tools.length > 0;
-        }
-        catch (error) {
-            return false;
-        }
-    }
-    /**
-     * Get client connection status
-     */
-    get isConnected() {
-        return this.transport !== null;
-    }
-}

package/build/test/config-allowed-groups.test.js

@@ -1,97 +0,0 @@
-/**
- * Tests for GITLAB_OAUTH_ALLOWED_GROUPS config resolution.
- *
- * Verifies that:
- *   - The new GITLAB_OAUTH_ALLOWED_GROUPS env var is preferred when set.
- *   - The deprecated GITLAB_ALLOWED_GROUPS is accepted as a fallback and
- *     sets the deprecation flag so callers can emit a warning.
- *   - When both are set, the new var wins and GITLAB_ALLOWED_GROUPS_RAW remains
- *     set, so callers can emit a "set but ignored" warning.
- *
- * config.ts reads process.env at module load, so each scenario runs in a
- * fresh child process — same pattern as test/stateless/config-ttl.test.ts.
- */
-import assert from "node:assert/strict";
-import { execFileSync } from "node:child_process";
-import * as path from "node:path";
-import * as url from "node:url";
-import { describe, test } from "node:test";
-const __dirname = path.dirname(url.fileURLToPath(import.meta.url));
-const CONFIG_PATH = path.resolve(__dirname, "../config.ts");
-function loadConfig(env) {
-    const script = `
-    import(${JSON.stringify(url.pathToFileURL(CONFIG_PATH).href)}).then((m) => {
-      const out = {
-        GITLAB_OAUTH_ALLOWED_GROUPS: m.GITLAB_OAUTH_ALLOWED_GROUPS ?? null,
-        GITLAB_OAUTH_ALLOWED_GROUPS_RAW: m.GITLAB_OAUTH_ALLOWED_GROUPS_RAW ?? null,
-        GITLAB_ALLOWED_GROUPS_RAW: m.GITLAB_ALLOWED_GROUPS_RAW ?? null,
-      };
-      process.stdout.write(JSON.stringify(out));
-    }).catch((err) => {
-      process.stderr.write(String(err && err.stack || err));
-      process.exit(2);
-    });
-  `;
-    const childEnv = {
-        ...process.env,
-    };
-    delete childEnv.GITLAB_OAUTH_ALLOWED_GROUPS;
-    delete childEnv.GITLAB_ALLOWED_GROUPS;
-    for (const [k, v] of Object.entries(env)) {
-        if (v === undefined) {
-            delete childEnv[k];
-        }
-        else {
-            childEnv[k] = v;
-        }
-    }
-    const stdout = execFileSync(process.execPath, ["--import", "tsx/esm", "--input-type=module", "--eval", script], { env: childEnv, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] });
-    return JSON.parse(stdout);
-}
-describe("config.ts — GITLAB_OAUTH_ALLOWED_GROUPS resolution", () => {
-    test("neither var set — resolved value and raws are null", () => {
-        const cfg = loadConfig({});
-        assert.equal(cfg.GITLAB_OAUTH_ALLOWED_GROUPS, null);
-        assert.equal(cfg.GITLAB_OAUTH_ALLOWED_GROUPS_RAW, null);
-        assert.equal(cfg.GITLAB_ALLOWED_GROUPS_RAW, null);
-    });
-    test("only new var set — resolved correctly, deprecated raw is null", () => {
-        const cfg = loadConfig({ GITLAB_OAUTH_ALLOWED_GROUPS: "my-org" });
-        assert.deepEqual(cfg.GITLAB_OAUTH_ALLOWED_GROUPS, ["my-org"]);
-        assert.equal(cfg.GITLAB_OAUTH_ALLOWED_GROUPS_RAW, "my-org");
-        assert.equal(cfg.GITLAB_ALLOWED_GROUPS_RAW, null);
-    });
-    test("only deprecated var set — resolved via fallback, deprecated raw is set", () => {
-        const cfg = loadConfig({ GITLAB_ALLOWED_GROUPS: "my-org" });
-        assert.deepEqual(cfg.GITLAB_OAUTH_ALLOWED_GROUPS, ["my-org"]);
-        assert.equal(cfg.GITLAB_ALLOWED_GROUPS_RAW, "my-org");
-        assert.equal(cfg.GITLAB_OAUTH_ALLOWED_GROUPS_RAW, null);
-    });
-    test("both vars set — new var wins, both raws are set (triggers 'set but ignored' warning)", () => {
-        const cfg = loadConfig({
-            GITLAB_OAUTH_ALLOWED_GROUPS: "new-org",
-            GITLAB_ALLOWED_GROUPS: "old-org",
-        });
-        assert.deepEqual(cfg.GITLAB_OAUTH_ALLOWED_GROUPS, ["new-org"]);
-        assert.equal(cfg.GITLAB_OAUTH_ALLOWED_GROUPS_RAW, "new-org");
-        assert.equal(cfg.GITLAB_ALLOWED_GROUPS_RAW, "old-org");
-    });
-    test("comma-separated values are split and trimmed", () => {
-        const cfg = loadConfig({
-            GITLAB_OAUTH_ALLOWED_GROUPS: "my-org/team-a , my-org/team-b , my-org",
-        });
-        assert.deepEqual(cfg.GITLAB_OAUTH_ALLOWED_GROUPS, [
-            "my-org/team-a",
-            "my-org/team-b",
-            "my-org",
-        ]);
-    });
-    test("empty string resolves to null", () => {
-        const cfg = loadConfig({ GITLAB_OAUTH_ALLOWED_GROUPS: "" });
-        assert.equal(cfg.GITLAB_OAUTH_ALLOWED_GROUPS, null);
-    });
-    test("whitespace-only entries are filtered out", () => {
-        const cfg = loadConfig({ GITLAB_OAUTH_ALLOWED_GROUPS: " , , " });
-        assert.equal(cfg.GITLAB_OAUTH_ALLOWED_GROUPS, null);
-    });
-});