@zereight/mcp-gitlab 2.1.70 → 2.2.1

package/build/test/test-json-schema.js

@@ -1,166 +0,0 @@
-#!/usr/bin/env ts-node
-import { z } from "zod";
-import { toJSONSchema } from "../utils/schema.js";
-function assert(condition, message) {
-    if (!condition) {
-        throw new Error(message);
-    }
-}
-function runTests() {
-    console.log("Testing toJSONSchema utility...");
-    const results = [];
-    // Test 1: Required field extraction
-    try {
-        const schema = z.object({
-            requiredField: z.string(),
-            optionalField: z.string().optional(),
-        });
-        const result = toJSONSchema(schema);
-        assert(result.required?.includes("requiredField"), "requiredField should be in required array");
-        assert(!result.required?.includes("optionalField"), "optionalField should NOT be in required array");
-        results.push({ name: "required field extraction", status: "passed" });
-    }
-    catch (error) {
-        results.push({
-            name: "required field extraction",
-            status: "failed",
-            error: error.message,
-        });
-    }
-    // Test 2: Nullable fields
-    try {
-        const schema = z.object({
-            nullableField: z.string().nullable(),
-            requiredField: z.string(),
-        });
-        const result = toJSONSchema(schema);
-        assert(result.required?.includes("requiredField"), "requiredField should be in required array");
-        assert(!result.required?.includes("nullableField"), "nullableField should NOT be in required array");
-        results.push({ name: "nullable fields", status: "passed" });
-    }
-    catch (error) {
-        results.push({
-            name: "nullable fields",
-            status: "failed",
-            error: error.message,
-        });
-    }
-    // Test 3: Optional nullable fields
-    try {
-        const schema = z.object({
-            optionalNullable: z.string().optional().nullable(),
-            requiredField: z.string(),
-        });
-        const result = toJSONSchema(schema);
-        assert(result.required?.includes("requiredField"), "requiredField should be in required array");
-        assert(!result.required?.includes("optionalNullable"), "optionalNullable should NOT be in required array");
-        results.push({ name: "optional nullable fields", status: "passed" });
-    }
-    catch (error) {
-        results.push({
-            name: "optional nullable fields",
-            status: "failed",
-            error: error.message,
-        });
-    }
-    // Test 4: Fields with defaults
-    try {
-        const schema = z.object({
-            fieldWithDefault: z.string().default("default-value"),
-            requiredField: z.string(),
-        });
-        const result = toJSONSchema(schema);
-        assert(result.required?.includes("requiredField"), "requiredField should be in required array");
-        assert(!result.required?.includes("fieldWithDefault"), "fieldWithDefault should NOT be in required array");
-        assert(result.properties.fieldWithDefault.default === "default-value", "default value should be preserved");
-        results.push({ name: "fields with defaults", status: "passed" });
-    }
-    catch (error) {
-        results.push({
-            name: "fields with defaults",
-            status: "failed",
-            error: error.message,
-        });
-    }
-    // Test 5: Nested objects with shared property names
-    try {
-        const schema = z.object({
-            foo: z.string(), // Required at root
-            nested: z.object({
-                foo: z.string().optional(), // Optional in nested, shares name with root
-            }),
-        });
-        const result = toJSONSchema(schema);
-        assert(result.required?.includes("foo"), "root foo should be in required array");
-        assert(result.required?.includes("nested"), "nested object should be in required array");
-        assert(result.properties.nested.required === undefined, "nested foo should NOT be in required array");
-        results.push({
-            name: "nested objects with shared property names",
-            status: "passed",
-        });
-    }
-    catch (error) {
-        results.push({
-            name: "nested objects with shared property names",
-            status: "failed",
-            error: error.message,
-        });
-    }
-    // Test 6: Coerced fields
-    try {
-        const schema = z.object({
-            coercedField: z.coerce.string(),
-            optionalCoercedField: z.coerce.string().optional(),
-        });
-        const result = toJSONSchema(schema);
-        assert(result.required?.includes("coercedField"), "coercedField should be in required array (z.coerce without optional)");
-        assert(!result.required?.includes("optionalCoercedField"), "optionalCoercedField should NOT be in required array (z.coerce with optional)");
-        results.push({ name: "coerced fields", status: "passed" });
-    }
-    catch (error) {
-        results.push({
-            name: "coerced fields",
-            status: "failed",
-            error: error.message,
-        });
-    }
-    // Test 7: Effects fields
-    try {
-        const schema = z.object({
-            effectRequired: z.preprocess(value => value, z.string()),
-            effectOptional: z.preprocess(value => value, z.string().optional()),
-        });
-        const result = toJSONSchema(schema);
-        assert(result.required?.includes("effectRequired"), "effectRequired should be in required array");
-        assert(!result.required?.includes("effectOptional"), "effectOptional should NOT be in required array");
-        results.push({ name: "effects fields", status: "passed" });
-    }
-    catch (error) {
-        results.push({
-            name: "effects fields",
-            status: "failed",
-            error: error.message,
-        });
-    }
-    // Print results
-    const passed = results.filter((r) => r.status === "passed").length;
-    const failed = results.filter((r) => r.status === "failed").length;
-    console.log("\nTest Results:");
-    console.log("=".repeat(50));
-    results.forEach((result) => {
-        if (result.status === "passed") {
-            console.log(`  ${result.name}: ${result.status}`);
-        }
-        else {
-            console.log(`  ${result.name}: ${result.status}`);
-            console.log(`    Error: ${result.error}`);
-        }
-    });
-    console.log("=".repeat(50));
-    console.log(`Total: ${results.length} tests`);
-    console.log(`Passed: ${passed}`);
-    console.log(`Failed: ${failed}`);
-    return { passed, failed };
-}
-// Run tests
-runTests();

package/build/test/test-list-group-members.js

@@ -1,150 +0,0 @@
-import { describe, test, before, after, beforeEach } from 'node:test';
-import assert from 'node:assert';
-import { spawn } from 'child_process';
-import { MockGitLabServer, findMockServerPort } from './utils/mock-gitlab-server.js';
-const MOCK_TOKEN = 'glpat-mock-token-12345';
-const TEST_GROUP_ID = '456';
-const directMembers = [
-    {
-        id: 1,
-        username: 'direct-user',
-        name: 'Direct User',
-        state: 'active',
-        avatar_url: null,
-        web_url: 'https://gitlab.mock/users/1',
-        access_level: 30,
-        created_at: '2024-01-01T00:00:00Z'
-    }
-];
-const inheritedMembers = [
-    {
-        id: 2,
-        username: 'inherited-user',
-        name: 'Inherited User',
-        state: 'active',
-        avatar_url: null,
-        web_url: 'https://gitlab.mock/users/2',
-        access_level: 20,
-        created_at: '2024-01-02T00:00:00Z'
-    }
-];
-async function callListGroupMembers(args, env) {
-    return new Promise((resolve, reject) => {
-        const proc = spawn('node', ['build/index.js'], {
-            stdio: ['pipe', 'pipe', 'pipe'],
-            env: {
-                ...process.env,
-                ...env,
-                GITLAB_READ_ONLY_MODE: 'true'
-            }
-        });
-        let output = '';
-        let errorOutput = '';
-        proc.stdout?.on('data', d => output += d);
-        proc.stderr?.on('data', d => errorOutput += d);
-        proc.on('close', (code) => {
-            if (code !== 0)
-                return reject(new Error(`Process exited with code ${code}: ${errorOutput}`));
-            const line = output.split('\n').find(l => l.startsWith('{'));
-            if (!line)
-                return reject(new Error('No JSON output found'));
-            try {
-                const response = JSON.parse(line);
-                if (response.error) {
-                    reject(response.error);
-                }
-                else {
-                    const content = response.result?.content?.[0]?.text;
-                    if (content) {
-                        try {
-                            resolve(JSON.parse(content));
-                        }
-                        catch (e) {
-                            reject(new Error(`Failed to parse tool output JSON: ${content}`));
-                        }
-                    }
-                    else {
-                        resolve(response.result);
-                    }
-                }
-            }
-            catch (e) {
-                reject(e);
-            }
-        });
-        proc.stdin?.end(JSON.stringify({
-            jsonrpc: "2.0", id: 1, method: "tools/call",
-            params: { name: "list_group_members", arguments: args }
-        }) + '\n');
-    });
-}
-describe('list_group_members', () => {
-    let mockGitLab;
-    let mockGitLabUrl;
-    let directEndpointHit = false;
-    let inheritedEndpointHit = false;
-    let queryParam = null;
-    before(async () => {
-        const mockPort = await findMockServerPort();
-        mockGitLab = new MockGitLabServer({
-            port: mockPort,
-            validTokens: [MOCK_TOKEN]
-        });
-        await mockGitLab.start();
-        mockGitLabUrl = mockGitLab.getUrl();
-        mockGitLab.addMockHandler('get', `/groups/${TEST_GROUP_ID}/members`, (req, res) => {
-            directEndpointHit = true;
-            queryParam = req.query.query ?? null;
-            res.json(directMembers);
-        });
-        mockGitLab.addMockHandler('get', `/groups/${TEST_GROUP_ID}/members/all`, (req, res) => {
-            inheritedEndpointHit = true;
-            res.json([...directMembers, ...inheritedMembers]);
-        });
-    });
-    beforeEach(() => {
-        directEndpointHit = false;
-        inheritedEndpointHit = false;
-        queryParam = null;
-    });
-    after(async () => {
-        await mockGitLab.stop();
-    });
-    describe('When listing group members', () => {
-        describe('with direct membership only', () => {
-            test('should return direct members', async () => {
-                const members = await callListGroupMembers({ group_id: TEST_GROUP_ID }, {
-                    GITLAB_API_URL: `${mockGitLabUrl}/api/v4`,
-                    GITLAB_PERSONAL_ACCESS_TOKEN: MOCK_TOKEN
-                });
-                assert.ok(Array.isArray(members), 'Response should be an array');
-                assert.strictEqual(members.length, 1, 'Should return direct members');
-                assert.strictEqual(members[0].username, 'direct-user');
-                assert.strictEqual(directEndpointHit, true, 'Direct members endpoint should be called');
-                assert.strictEqual(inheritedEndpointHit, false, 'Inherited members endpoint should not be called');
-            });
-        });
-        describe('with include_inheritance', () => {
-            test('should return inherited members', async () => {
-                const members = await callListGroupMembers({ group_id: TEST_GROUP_ID, include_inheritance: true }, {
-                    GITLAB_API_URL: `${mockGitLabUrl}/api/v4`,
-                    GITLAB_PERSONAL_ACCESS_TOKEN: MOCK_TOKEN
-                });
-                assert.ok(Array.isArray(members), 'Response should be an array');
-                assert.strictEqual(members.length, 2, 'Should return inherited members');
-                assert.strictEqual(members[1].username, 'inherited-user');
-                assert.strictEqual(inheritedEndpointHit, true, 'Inherited members endpoint should be called');
-                assert.strictEqual(directEndpointHit, false, 'Direct members endpoint should not be called');
-            });
-        });
-        describe('with query', () => {
-            test('should pass query to the members endpoint', async () => {
-                await callListGroupMembers({ group_id: TEST_GROUP_ID, query: 'alice' }, {
-                    GITLAB_API_URL: `${mockGitLabUrl}/api/v4`,
-                    GITLAB_PERSONAL_ACCESS_TOKEN: MOCK_TOKEN
-                });
-                assert.strictEqual(queryParam, 'alice', 'Query parameter should be forwarded');
-            });
-        });
-    });
-});

package/build/test/test-list-group-merge-requests.js

@@ -1,165 +0,0 @@
-import { describe, test, before, after, beforeEach } from "node:test";
-import assert from "node:assert";
-import { spawn } from "child_process";
-import { MockGitLabServer, findMockServerPort } from "./utils/mock-gitlab-server.js";
-const MOCK_TOKEN = "glpat-mock-token-12345";
-const TEST_GROUP_ID = "my-group/sub-group";
-const groupMergeRequests = [
-    {
-        id: 1,
-        iid: 10,
-        project_id: 123,
-        title: "Group MR 1",
-        description: "First MR of the group",
-        state: "opened",
-        created_at: "2024-01-01T00:00:00Z",
-        updated_at: "2024-01-02T00:00:00Z",
-        merged_at: null,
-        closed_at: null,
-        target_branch: "main",
-        source_branch: "feature/one",
-        web_url: "https://gitlab.mock/my-group/project-a/-/merge_requests/10",
-        merge_commit_sha: null,
-        author: {
-            id: 1,
-            username: "test-user",
-            name: "Test User",
-        },
-    },
-    {
-        id: 2,
-        iid: 4,
-        project_id: 456,
-        title: "Group MR 2",
-        description: "Second MR of the group",
-        state: "opened",
-        created_at: "2024-01-03T00:00:00Z",
-        updated_at: "2024-01-04T00:00:00Z",
-        merged_at: null,
-        closed_at: null,
-        target_branch: "main",
-        source_branch: "feature/two",
-        web_url: "https://gitlab.mock/my-group/project-b/-/merge_requests/4",
-        merge_commit_sha: null,
-        author: {
-            id: 2,
-            username: "other-user",
-            name: "Other User",
-        },
-    },
-];
-async function callListGroupMergeRequests(args, env) {
-    return new Promise((resolve, reject) => {
-        const proc = spawn("node", ["build/index.js"], {
-            stdio: ["pipe", "pipe", "pipe"],
-            env: {
-                ...process.env,
-                ...env,
-                GITLAB_READ_ONLY_MODE: "true",
-            },
-        });
-        let output = "";
-        let errorOutput = "";
-        proc.stdout?.on("data", d => (output += d));
-        proc.stderr?.on("data", d => (errorOutput += d));
-        proc.on("close", code => {
-            if (code !== 0)
-                return reject(new Error(`Process exited with code ${code}: ${errorOutput}`));
-            const line = output.split("\n").find(l => l.startsWith("{"));
-            if (!line)
-                return reject(new Error("No JSON output found"));
-            try {
-                const response = JSON.parse(line);
-                if (response.error) {
-                    reject(response.error);
-                }
-                else {
-                    const content = response.result?.content?.[0]?.text;
-                    if (content) {
-                        try {
-                            resolve(JSON.parse(content));
-                        }
-                        catch {
-                            reject(new Error(`Failed to parse tool output JSON: ${content}`));
-                        }
-                    }
-                    else {
-                        resolve(response.result);
-                    }
-                }
-            }
-            catch (e) {
-                reject(e);
-            }
-        });
-        proc.stdin?.end(JSON.stringify({
-            jsonrpc: "2.0",
-            id: 1,
-            method: "tools/call",
-            params: { name: "list_group_merge_requests", arguments: args },
-        }) + "\n");
-    });
-}
-describe("list_group_merge_requests", () => {
-    let mockGitLab;
-    let mockGitLabUrl;
-    let capturedUrl;
-    before(async () => {
-        const mockPort = await findMockServerPort();
-        mockGitLab = new MockGitLabServer({
-            port: mockPort,
-            validTokens: [MOCK_TOKEN],
-        });
-        await mockGitLab.start();
-        mockGitLabUrl = mockGitLab.getUrl();
-        mockGitLab.addMockHandler("get", `/groups/${encodeURIComponent(TEST_GROUP_ID)}/merge_requests`, (req, res) => {
-            capturedUrl = req.originalUrl;
-            res.json(groupMergeRequests);
-        });
-    });
-    beforeEach(() => {
-        capturedUrl = undefined;
-    });
-    after(async () => {
-        await mockGitLab.stop();
-    });
-    test("lists merge requests of every project in the group", async () => {
-        const mrs = await callListGroupMergeRequests({ group_id: TEST_GROUP_ID }, {
-            GITLAB_API_URL: `${mockGitLabUrl}/api/v4`,
-            GITLAB_PERSONAL_ACCESS_TOKEN: MOCK_TOKEN,
-        });
-        assert.ok(Array.isArray(mrs), "Response should be an array");
-        assert.strictEqual(mrs.length, 2, "Should return the 2 mock MRs");
-        assert.strictEqual(mrs[0].title, "Group MR 1");
-        assert.notStrictEqual(String(mrs[0].project_id), String(mrs[1].project_id), "MRs should come from different projects");
-    });
-    test("forwards group-specific and shared filters as query parameters", async () => {
-        await callListGroupMergeRequests({
-            group_id: TEST_GROUP_ID,
-            state: "opened",
-            non_archived: true,
-            source_project_id: "123",
-            labels: ["backend", "urgent"],
-            approved_by_usernames: ["alice", "bob"],
-        }, {
-            GITLAB_API_URL: `${mockGitLabUrl}/api/v4`,
-            GITLAB_PERSONAL_ACCESS_TOKEN: MOCK_TOKEN,
-        });
-        assert.ok(capturedUrl, "Mock handler should have received a request");
-        assert.match(capturedUrl, /state=opened/, "Request URL should carry state");
-        assert.match(capturedUrl, /non_archived=true/, "Request URL should carry non_archived");
-        assert.match(capturedUrl, /source_project_id=123/, "Request URL should carry source_project_id");
-        assert.match(capturedUrl, /labels=backend%2Curgent/, "Labels should be comma-joined");
-        assert.match(capturedUrl, /approved_by_usernames%5B%5D=alice/, "approved_by_usernames should use bracket-array form (URL-encoded)");
-        assert.match(capturedUrl, /approved_by_usernames%5B%5D=bob/);
-    });
-    test("drops the mutually exclusive *_id filter when a *_username is given", async () => {
-        await callListGroupMergeRequests({ group_id: TEST_GROUP_ID, author_id: "7", author_username: "alice" }, {
-            GITLAB_API_URL: `${mockGitLabUrl}/api/v4`,
-            GITLAB_PERSONAL_ACCESS_TOKEN: MOCK_TOKEN,
-        });
-        assert.ok(capturedUrl, "Mock handler should have received a request");
-        assert.match(capturedUrl, /author_username=alice/, "author_username should be forwarded");
-        assert.doesNotMatch(capturedUrl, /author_id=/, "author_id should be dropped");
-    });
-});

package/build/test/test-list-issues.js

@@ -1,170 +0,0 @@
-import { describe, test, before, after } from "node:test";
-import assert from "node:assert";
-import { spawn } from "child_process";
-import { MockGitLabServer, findMockServerPort } from "./utils/mock-gitlab-server.js";
-const MOCK_TOKEN = "glpat-mock-token-12345";
-const TEST_PROJECT_ID = "123";
-async function callListIssuesResult(args = {}, env) {
-    return new Promise((resolve, reject) => {
-        const proc = spawn("node", ["build/index.js"], {
-            stdio: ["pipe", "pipe", "pipe"],
-            env: {
-                ...process.env,
-                ...env,
-                GITLAB_READ_ONLY_MODE: "true",
-            },
-        });
-        let output = "";
-        let errorOutput = "";
-        proc.stdout?.on("data", d => (output += d));
-        proc.stderr?.on("data", d => (errorOutput += d));
-        proc.on("close", code => {
-            if (code !== 0) {
-                return reject(new Error(`Process exited with code ${code}: ${errorOutput}`));
-            }
-            const line = output.split("\n").find(l => l.startsWith("{"));
-            if (!line) {
-                return reject(new Error("No JSON output found"));
-            }
-            try {
-                const response = JSON.parse(line);
-                if (response.error) {
-                    reject(response.error);
-                }
-                else {
-                    const content = response.result?.content?.[0]?.text;
-                    if (content) {
-                        try {
-                            resolve({ data: JSON.parse(content), text: content });
-                        }
-                        catch {
-                            reject(new Error(`Failed to parse tool output JSON: ${content}`));
-                        }
-                    }
-                    else {
-                        resolve({ data: response.result });
-                    }
-                }
-            }
-            catch (e) {
-                reject(e);
-            }
-        });
-        proc.stdin?.end(JSON.stringify({
-            jsonrpc: "2.0",
-            id: 1,
-            method: "tools/call",
-            params: { name: "list_issues", arguments: args },
-        }) + "\n");
-    });
-}
-async function callListIssues(args = {}, env) {
-    return (await callListIssuesResult(args, env)).data;
-}
-describe("list_issues", () => {
-    let mockGitLab;
-    let mockGitLabUrl;
-    before(async () => {
-        const mockPort = await findMockServerPort();
-        mockGitLab = new MockGitLabServer({
-            port: mockPort,
-            validTokens: [MOCK_TOKEN],
-        });
-        await mockGitLab.start();
-        mockGitLabUrl = mockGitLab.getUrl();
-    });
-    after(async () => {
-        await mockGitLab.stop();
-    });
-    test("lists project-specific issues", async () => {
-        const issues = await callListIssues({ project_id: TEST_PROJECT_ID }, {
-            GITLAB_API_URL: `${mockGitLabUrl}/api/v4`,
-            GITLAB_PERSONAL_ACCESS_TOKEN: MOCK_TOKEN,
-        });
-        assert.ok(Array.isArray(issues), "Response should be an array");
-        assert.strictEqual(issues.length, 1, "Should return 1 mock issue");
-        const firstIssue = issues[0];
-        assert.ok(firstIssue && typeof firstIssue === "object" && "title" in firstIssue);
-        const title = Reflect.get(firstIssue, "title");
-        assert.strictEqual(title, "Test Issue 1");
-    });
-    test("returns compact JSON text", async () => {
-        const result = await callListIssuesResult({ project_id: TEST_PROJECT_ID }, {
-            GITLAB_API_URL: `${mockGitLabUrl}/api/v4`,
-            GITLAB_PERSONAL_ACCESS_TOKEN: MOCK_TOKEN,
-        });
-        assert.ok(result.text, "Tool response should include text content");
-        assert.doesNotMatch(result.text, /\n\s+"/, "Tool response JSON should not be pretty-printed");
-        assert.ok(Array.isArray(result.data), "Response should remain valid JSON");
-    });
-    test("prefers author_username over author_id when both are provided", async () => {
-        let capturedUrl;
-        mockGitLab.addMockHandler("get", `/projects/${TEST_PROJECT_ID}/issues`, (req, res) => {
-            capturedUrl = req.originalUrl;
-            res.json([]);
-        });
-        try {
-            await callListIssues({
-                project_id: TEST_PROJECT_ID,
-                author_id: "42",
-                author_username: "alice",
-            }, {
-                GITLAB_API_URL: `${mockGitLabUrl}/api/v4`,
-                GITLAB_PERSONAL_ACCESS_TOKEN: MOCK_TOKEN,
-            });
-            assert.ok(capturedUrl, "Mock handler should have received a request");
-            assert.match(capturedUrl, /author_username=alice/, "Request should include author_username");
-            assert.doesNotMatch(capturedUrl, /author_id=/, "Request should not include author_id");
-        }
-        finally {
-            mockGitLab.clearCustomHandlers();
-        }
-    });
-    test("drops blank entries inside array filters", async () => {
-        let capturedUrl;
-        mockGitLab.addMockHandler("get", `/projects/${TEST_PROJECT_ID}/issues`, (req, res) => {
-            capturedUrl = req.originalUrl;
-            res.json([]);
-        });
-        try {
-            await callListIssues({
-                project_id: TEST_PROJECT_ID,
-                labels: ["", "  ", "bug"],
-                assignee_username: ["", "alice"],
-            }, {
-                GITLAB_API_URL: `${mockGitLabUrl}/api/v4`,
-                GITLAB_PERSONAL_ACCESS_TOKEN: MOCK_TOKEN,
-            });
-            assert.ok(capturedUrl, "Mock handler should have received a request");
-            const params = new URL(capturedUrl, "http://localhost").searchParams;
-            assert.deepStrictEqual(params.getAll("labels[]"), ["bug"], "Blank label entries should be dropped while non-blank ones are kept");
-            assert.deepStrictEqual(params.getAll("assignee_username[]"), ["alice"], "Blank assignee_username entries should be dropped while non-blank ones are kept");
-        }
-        finally {
-            mockGitLab.clearCustomHandlers();
-        }
-    });
-    test("omits array filters whose entries are all blank", async () => {
-        let capturedUrl;
-        mockGitLab.addMockHandler("get", `/projects/${TEST_PROJECT_ID}/issues`, (req, res) => {
-            capturedUrl = req.originalUrl;
-            res.json([]);
-        });
-        try {
-            const issues = await callListIssues({
-                project_id: TEST_PROJECT_ID,
-                labels: ["", " "],
-                assignee_username: [""],
-            }, {
-                GITLAB_API_URL: `${mockGitLabUrl}/api/v4`,
-                GITLAB_PERSONAL_ACCESS_TOKEN: MOCK_TOKEN,
-            });
-            assert.deepStrictEqual(issues, []);
-            assert.ok(capturedUrl, "Mock handler should have received a request");
-            assert.strictEqual(new URL(capturedUrl, "http://localhost").search, "", "Array filters with only blank entries should not be serialized");
-        }
-        finally {
-            mockGitLab.clearCustomHandlers();
-        }
-    });
-});