@zereight/mcp-gitlab 2.1.69 → 2.2.0

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

package/build/test/create-commit-actions.test.js

@@ -1,102 +0,0 @@
-import assert from "node:assert/strict";
-import { describe, it } from "node:test";
-import { FileOperationSchema } from "../schemas.js";
-import { fileOperationsIncludeDeleteOrMove, toGitLabCommitActions, } from "../utils/gitlab-commit-actions.js";
-function firstAction(actions) {
-    const entry = actions[0];
-    if (!entry) {
-        throw new Error("expected at least one commit action");
-    }
-    return entry;
-}
-describe("When mapping file operations to GitLab commit actions", () => {
-    describe("with a plain text file and no per-file encoding", () => {
-        it("should default the action to create", () => {
-            const entry = firstAction(toGitLabCommitActions([{ path: "a.txt", content: "hi" }], "text"));
-            assert.equal(entry.action, "create");
-        });
-        it("should keep the content unchanged when the global encoding is text", () => {
-            const entry = firstAction(toGitLabCommitActions([{ path: "a.txt", content: "hi" }], "text"));
-            assert.equal(entry.content, "hi");
-        });
-        it("should set encoding to the global text value", () => {
-            const entry = firstAction(toGitLabCommitActions([{ path: "a.txt", content: "hi" }], "text"));
-            assert.equal(entry.encoding, "text");
-        });
-    });
-    describe("with a plain text file and global base64 encoding", () => {
-        it("should base64-encode the content", () => {
-            const entry = firstAction(toGitLabCommitActions([{ path: "a.txt", content: "hi" }], "base64"));
-            assert.equal(entry.content, Buffer.from("hi").toString("base64"));
-        });
-        it("should set encoding to base64", () => {
-            const entry = firstAction(toGitLabCommitActions([{ path: "a.txt", content: "hi" }], "base64"));
-            assert.equal(entry.encoding, "base64");
-        });
-    });
-    describe("with an explicit per-file encoding", () => {
-        it("should pass text content through when encoding is text even if global is base64", () => {
-            const entry = firstAction(toGitLabCommitActions([{ path: "a.txt", content: "hi", encoding: "text" }], "base64"));
-            assert.equal(entry.content, "hi");
-        });
-        it("should keep the explicit text encoding on the payload", () => {
-            const entry = firstAction(toGitLabCommitActions([{ path: "a.txt", content: "hi", encoding: "text" }], "base64"));
-            assert.equal(entry.encoding, "text");
-        });
-        it("should pass base64 content through without encoding it again", () => {
-            const entry = firstAction(toGitLabCommitActions([{ path: "logo.png", content: "aGk=", encoding: "base64" }], "text"));
-            assert.equal(entry.content, "aGk=");
-        });
-    });
-    describe("with action delete", () => {
-        it("should omit content from the payload", () => {
-            const entry = firstAction(toGitLabCommitActions([{ path: "a.txt", action: "delete" }], "text"));
-            assert.equal("content" in entry, false);
-        });
-        it("should omit encoding from the payload", () => {
-            const entry = firstAction(toGitLabCommitActions([{ path: "a.txt", action: "delete" }], "text"));
-            assert.equal("encoding" in entry, false);
-        });
-    });
-    describe("with action move", () => {
-        it("should omit content when the move has no new content", () => {
-            const entry = firstAction(toGitLabCommitActions([{ path: "b.txt", action: "move", previous_path: "a.txt" }], "text"));
-            assert.equal("content" in entry, false);
-        });
-        it("should include previous_path", () => {
-            const entry = firstAction(toGitLabCommitActions([{ path: "b.txt", action: "move", previous_path: "a.txt" }], "text"));
-            assert.equal(entry.previous_path, "a.txt");
-        });
-        it("should include content when a move supplies replacement content", () => {
-            const entry = firstAction(toGitLabCommitActions([{ path: "b.txt", action: "move", previous_path: "a.txt", content: "new" }], "text"));
-            assert.equal(entry.content, "new");
-        });
-    });
-    describe("with create or update missing content", () => {
-        it("should reject a create without content before sending an empty file", () => {
-            assert.throws(() => toGitLabCommitActions([{ path: "a.txt" }], "text"), /content is required when action is 'create'/);
-        });
-        it("should reject the FileOperation schema for create without content", () => {
-            const parsed = FileOperationSchema.safeParse({ path: "a.txt" });
-            assert.equal(parsed.success, false);
-        });
-    });
-});
-describe("When checking push_files actions against modify mode", () => {
-    describe("with delete or move entries", () => {
-        it("should treat delete as blocked", () => {
-            assert.equal(fileOperationsIncludeDeleteOrMove([{ action: "delete" }]), true);
-        });
-        it("should treat move as blocked", () => {
-            assert.equal(fileOperationsIncludeDeleteOrMove([{ action: "move" }]), true);
-        });
-    });
-    describe("with create or update entries", () => {
-        it("should allow omitted action", () => {
-            assert.equal(fileOperationsIncludeDeleteOrMove([{}]), false);
-        });
-        it("should allow update", () => {
-            assert.equal(fileOperationsIncludeDeleteOrMove([{ action: "update" }]), false);
-        });
-    });
-});

package/build/test/draft-note-schema.test.js

@@ -1,44 +0,0 @@
-import assert from "node:assert/strict";
-import { test } from "node:test";
-import { GitLabDraftNoteSchema } from "../schemas.js";
-test("draft note schema keeps Draft Notes API fields and drops fake timestamps", () => {
-    const parsed = GitLabDraftNoteSchema.parse({
-        id: 42,
-        author_id: 7,
-        note: "looks wrong on this line",
-        line_code: "a1b2c3d4e5f6_12_17",
-        merge_request_id: 99,
-        commit_id: "abc123",
-        discussion_id: null,
-        position: { new_path: "src/app.ts", new_line: 17 },
-        resolve_discussion: false,
-        // Notes-API leftovers that Draft Notes API never returns — must be stripped
-        created_at: "2024-01-01T00:00:00Z",
-        updated_at: "2024-01-02T00:00:00Z",
-    });
-    assert.equal(parsed.id, "42");
-    assert.equal(parsed.author_id, 7);
-    assert.equal(parsed.body, "looks wrong on this line");
-    assert.equal(parsed.line_code, "a1b2c3d4e5f6_12_17");
-    assert.equal(parsed.merge_request_id, 99);
-    assert.equal(parsed.commit_id, "abc123");
-    assert.equal(parsed.discussion_id, null);
-    assert.equal(parsed.resolve_discussion, false);
-    assert.equal("created_at" in parsed, false);
-    assert.equal("updated_at" in parsed, false);
-});
-test("draft note schema preserves null line_code for unresolved positions", () => {
-    const parsed = GitLabDraftNoteSchema.parse({
-        id: "43",
-        author_id: 7,
-        note: "orphan draft",
-        line_code: null,
-        merge_request_id: 99,
-        commit_id: null,
-        discussion_id: null,
-        position: null,
-        resolve_discussion: false,
-    });
-    assert.equal(parsed.line_code, null);
-    assert.equal(parsed.commit_id, null);
-});