@zereight/mcp-gitlab 2.1.70 → 2.2.1

package/build/test/test-tags.js

@@ -1,220 +0,0 @@
-import { after, before, describe, test } 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-tags";
-const TEST_PROJECT_ID = "123";
-const TEST_TAG_NAME = "v1.0.0";
-function buildTag(overrides = {}) {
-    return {
-        name: TEST_TAG_NAME,
-        message: "Annotated release tag",
-        target: "abc123def4567890",
-        commit: {
-            id: "abc123def4567890",
-            short_id: "abc123de",
-            title: "Release v1.0.0",
-            created_at: "2026-03-13T10:00:00.000Z",
-            parent_ids: ["1111111111111111"],
-            message: "Release v1.0.0",
-            author_name: "Test User",
-            author_email: "test@example.com",
-            authored_date: "2026-03-13T09:55:00.000Z",
-            committer_name: "Test User",
-            committer_email: "test@example.com",
-            committed_date: "2026-03-13T10:00:00.000Z",
-        },
-        release: {
-            tag_name: TEST_TAG_NAME,
-            description: "Release notes",
-        },
-        protected: false,
-        created_at: "2026-03-13T10:00:00.000Z",
-        ...overrides,
-    };
-}
-async function callTool(toolName, args, env) {
-    return new Promise((resolve, reject) => {
-        const proc = spawn("node", ["build/index.js"], {
-            stdio: ["pipe", "pipe", "pipe"],
-            env: {
-                ...process.env,
-                ...env,
-            },
-        });
-        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);
-                    return;
-                }
-                const content = response.result?.content?.[0]?.text;
-                if (!content) {
-                    resolve(response.result);
-                    return;
-                }
-                try {
-                    resolve(JSON.parse(content));
-                }
-                catch {
-                    resolve(content);
-                }
-            }
-            catch (error) {
-                reject(error);
-            }
-        });
-        proc.stdin?.end(JSON.stringify({
-            jsonrpc: "2.0",
-            id: 1,
-            method: "tools/call",
-            params: { name: toolName, arguments: args },
-        }) + "\n");
-    });
-}
-describe("tag tools", () => {
-    let mockGitLab;
-    let mockGitLabUrl;
-    before(async () => {
-        const mockPort = await findMockServerPort();
-        mockGitLab = new MockGitLabServer({
-            port: mockPort,
-            validTokens: [MOCK_TOKEN],
-        });
-        mockGitLab.addMockHandler("get", `/projects/${TEST_PROJECT_ID}/repository/tags`, (req, res) => {
-            assert.strictEqual(req.query.search, "^v");
-            assert.strictEqual(req.query.order_by, "version");
-            assert.strictEqual(req.query.sort, "desc");
-            assert.strictEqual(req.query.page, "2");
-            assert.strictEqual(req.query.per_page, "10");
-            res.json([buildTag()]);
-        });
-        mockGitLab.addMockHandler("get", `/projects/${TEST_PROJECT_ID}/repository/tags/${encodeURIComponent(TEST_TAG_NAME)}`, (_req, res) => {
-            res.json(buildTag());
-        });
-        mockGitLab.addMockHandler("post", `/projects/${TEST_PROJECT_ID}/repository/tags`, (req, res) => {
-            if (req.body.tag_name === "v-no-release") {
-                const tag = buildTag({ name: "v-no-release", message: null });
-                res.json(Object.fromEntries(Object.entries(tag).filter(([key]) => key !== "release")));
-                return;
-            }
-            assert.deepStrictEqual(req.body, {
-                tag_name: TEST_TAG_NAME,
-                ref: "main",
-                message: "Release tag",
-            });
-            res.json(buildTag({ created_at: null }));
-        });
-        mockGitLab.addMockHandler("delete", `/projects/${TEST_PROJECT_ID}/repository/tags/${encodeURIComponent(TEST_TAG_NAME)}`, (_req, res) => {
-            res.status(204).send();
-        });
-        mockGitLab.addMockHandler("get", `/projects/${TEST_PROJECT_ID}/repository/tags/${encodeURIComponent(TEST_TAG_NAME)}/signature`, (_req, res) => {
-            res.json({
-                signature_type: "X509",
-                verification_status: "unverified",
-                x509_certificate: {
-                    id: 1,
-                    subject: "CN=Test User,O=Example",
-                    subject_key_identifier: "A1725E379E7B25B2",
-                    email: null,
-                    serial_number: 123456789,
-                    certificate_status: "good",
-                    x509_issuer: {
-                        id: 1,
-                        subject: "CN=Example CA,O=Example",
-                        subject_key_identifier: "C6411E6F5B9E2CFD",
-                        crl_url: null,
-                    },
-                },
-            });
-        });
-        await mockGitLab.start();
-        mockGitLabUrl = mockGitLab.getUrl();
-    });
-    after(async () => {
-        await mockGitLab.stop();
-    });
-    const env = () => ({
-        GITLAB_API_URL: `${mockGitLabUrl}/api/v4`,
-        GITLAB_PERSONAL_ACCESS_TOKEN: MOCK_TOKEN,
-        GITLAB_TOOLSETS: "tags",
-    });
-    test("list_tags returns parsed tags with query filters", async () => {
-        const result = await callTool("list_tags", {
-            project_id: TEST_PROJECT_ID,
-            search: "^v",
-            order_by: "version",
-            sort: "desc",
-            page: 2,
-            per_page: 10,
-        }, env());
-        assert.ok(Array.isArray(result));
-        assert.strictEqual(result.length, 1);
-        assert.strictEqual(result[0].name, TEST_TAG_NAME);
-    });
-    test("get_tag returns a single tag", async () => {
-        const result = await callTool("get_tag", { project_id: TEST_PROJECT_ID, tag_name: TEST_TAG_NAME }, env());
-        assert.strictEqual(result.name, TEST_TAG_NAME);
-        assert.strictEqual(result.commit.short_id, "abc123de");
-    });
-    test("create_tag posts the expected payload", async () => {
-        const result = await callTool("create_tag", {
-            project_id: TEST_PROJECT_ID,
-            tag_name: TEST_TAG_NAME,
-            ref: "main",
-            message: "Release tag",
-        }, env());
-        assert.strictEqual(result.name, TEST_TAG_NAME);
-        assert.strictEqual(result.release.description, "Release notes");
-        assert.strictEqual(result.created_at, null);
-    });
-    test("create_tag succeeds when GitLab omits the release field", async () => {
-        const result = await callTool("create_tag", {
-            project_id: TEST_PROJECT_ID,
-            tag_name: "v-no-release",
-            ref: "main",
-        }, env());
-        assert.strictEqual(result.name, "v-no-release");
-        assert.strictEqual(result.release, undefined);
-    });
-    test("delete_tag returns a success payload", async () => {
-        const result = await callTool("delete_tag", { project_id: TEST_PROJECT_ID, tag_name: TEST_TAG_NAME }, env());
-        assert.deepStrictEqual(result, {
-            status: "success",
-            message: `Tag '${TEST_TAG_NAME}' deleted successfully`,
-        });
-    });
-    test("get_tag_signature returns signature data", async () => {
-        const result = await callTool("get_tag_signature", { project_id: TEST_PROJECT_ID, tag_name: TEST_TAG_NAME }, env());
-        assert.deepStrictEqual(result, {
-            signature_type: "X509",
-            verification_status: "unverified",
-            x509_certificate: {
-                id: 1,
-                subject: "CN=Test User,O=Example",
-                subject_key_identifier: "A1725E379E7B25B2",
-                email: null,
-                serial_number: 123456789,
-                certificate_status: "good",
-                x509_issuer: {
-                    id: 1,
-                    subject: "CN=Example CA,O=Example",
-                    subject_key_identifier: "C6411E6F5B9E2CFD",
-                    crl_url: null,
-                },
-            },
-        });
-    });
-});

package/build/test/test-todos.js

@@ -1,195 +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-todos-test-token";
-async function callTool(toolName, args, env) {
-    return new Promise((resolve, reject) => {
-        const proc = spawn("node", ["build/index.js"], {
-            stdio: ["pipe", "pipe", "pipe"],
-            env: {
-                ...process.env,
-                ...env,
-            },
-        });
-        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;
-                    resolve(content ? JSON.parse(content) : response.result);
-                }
-            }
-            catch (e) {
-                reject(e);
-            }
-        });
-        proc.stdin?.end(JSON.stringify({
-            jsonrpc: "2.0",
-            id: 1,
-            method: "tools/call",
-            params: args === undefined ? { name: toolName } : { name: toolName, arguments: args },
-        }) + "\n");
-    });
-}
-async function listToolNames(env) {
-    return new Promise((resolve, reject) => {
-        const proc = spawn("node", ["build/index.js"], {
-            stdio: ["pipe", "pipe", "pipe"],
-            env: {
-                ...process.env,
-                ...env,
-            },
-        });
-        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 {
-                    resolve(response.result.tools.map((tool) => tool.name));
-                }
-            }
-            catch (e) {
-                reject(e);
-            }
-        });
-        proc.stdin?.end(JSON.stringify({
-            jsonrpc: "2.0",
-            id: 1,
-            method: "tools/list",
-            params: {},
-        }) + "\n");
-    });
-}
-function todoFixture(id, state = "pending") {
-    return {
-        id,
-        project: { id: 123, path_with_namespace: "group/project" },
-        author: { id: 1, username: "root" },
-        action_name: "marked",
-        target_type: "MergeRequest",
-        target: { id: 34, iid: 7, project_id: 123, title: "Review this MR" },
-        target_url: "https://gitlab.example.com/group/project/-/merge_requests/7",
-        body: "Review this MR",
-        state,
-        created_at: "2026-01-01T00:00:00.000Z",
-        updated_at: "2026-01-01T00:00:00.000Z",
-    };
-}
-describe("GitLab todos tools", () => {
-    let mockGitLab;
-    let mockGitLabUrl;
-    before(async () => {
-        const mockPort = await findMockServerPort();
-        mockGitLab = new MockGitLabServer({
-            port: mockPort,
-            validTokens: [MOCK_TOKEN],
-        });
-        mockGitLab.addMockHandler("get", "/todos", (req, res) => {
-            assert.strictEqual(req.query.state, "pending");
-            assert.strictEqual(req.query.action, "assigned");
-            assert.strictEqual(req.query.project_id, "123");
-            assert.strictEqual(req.query.page, "2");
-            assert.strictEqual(req.query.per_page, "5");
-            res.json([todoFixture(102)]);
-        });
-        mockGitLab.addMockHandler("post", "/todos/102/mark_as_done", (req, res) => {
-            res.json(todoFixture(102, "done"));
-        });
-        mockGitLab.addMockHandler("post", "/todos/mark_as_done", (req, res) => {
-            res.status(204).send();
-        });
-        await mockGitLab.start();
-        mockGitLabUrl = mockGitLab.getUrl();
-    });
-    after(async () => {
-        await mockGitLab.stop();
-    });
-    test("list_todos sends filters and returns todos", async () => {
-        const result = await callTool("list_todos", {
-            state: "pending",
-            action: "assigned",
-            project_id: 123,
-            page: 2,
-            per_page: 5,
-        }, {
-            GITLAB_API_URL: `${mockGitLabUrl}/api/v4`,
-            GITLAB_PERSONAL_ACCESS_TOKEN: MOCK_TOKEN,
-        });
-        assert.ok(Array.isArray(result));
-        assert.strictEqual(result[0].id, 102);
-        assert.strictEqual(result[0].state, "pending");
-    });
-    test("mark_todo_done marks one todo done", async () => {
-        const result = await callTool("mark_todo_done", { id: 102 }, {
-            GITLAB_API_URL: `${mockGitLabUrl}/api/v4`,
-            GITLAB_PERSONAL_ACCESS_TOKEN: MOCK_TOKEN,
-        });
-        assert.strictEqual(result.id, 102);
-        assert.strictEqual(result.state, "done");
-    });
-    test("mark_all_todos_done reports success", async () => {
-        const result = await callTool("mark_all_todos_done", {}, {
-            GITLAB_API_URL: `${mockGitLabUrl}/api/v4`,
-            GITLAB_PERSONAL_ACCESS_TOKEN: MOCK_TOKEN,
-        });
-        assert.deepStrictEqual(result, {
-            status: "success",
-            message: "All pending to-do items marked as done",
-        });
-    });
-    test("mark_all_todos_done accepts omitted arguments", async () => {
-        const result = await callTool("mark_all_todos_done", undefined, {
-            GITLAB_API_URL: `${mockGitLabUrl}/api/v4`,
-            GITLAB_PERSONAL_ACCESS_TOKEN: MOCK_TOKEN,
-        });
-        assert.deepStrictEqual(result, {
-            status: "success",
-            message: "All pending to-do items marked as done",
-        });
-    });
-    test("todo tools are visible in the default issues toolset", async () => {
-        const tools = await listToolNames({
-            GITLAB_API_URL: `${mockGitLabUrl}/api/v4`,
-            GITLAB_PERSONAL_ACCESS_TOKEN: MOCK_TOKEN,
-        });
-        assert.ok(tools.includes("list_todos"));
-        assert.ok(tools.includes("mark_todo_done"));
-        assert.ok(tools.includes("mark_all_todos_done"));
-    });
-    test("read-only mode keeps list_todos and hides todo mutations", async () => {
-        const tools = await listToolNames({
-            GITLAB_API_URL: `${mockGitLabUrl}/api/v4`,
-            GITLAB_PERSONAL_ACCESS_TOKEN: MOCK_TOKEN,
-            GITLAB_READ_ONLY_MODE: "true",
-        });
-        assert.ok(tools.includes("list_todos"));
-        assert.ok(!tools.includes("mark_todo_done"));
-        assert.ok(!tools.includes("mark_all_todos_done"));
-    });
-});