@zereight/mcp-gitlab 2.1.70 → 2.2.1

package/build/test/test-blank-filters.js

@@ -1,156 +0,0 @@
-import { describe, test, before, after, afterEach } 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";
-// Cases below cover tools outside the default toolsets, so every toolset is enabled.
-const TOOLSET_ENV = { GITLAB_TOOLSETS: "all" };
-// Helper to run an MCP tool through the stdio server
-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,
-                ...TOOLSET_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(new Error(JSON.stringify(response.error)));
-                    return;
-                }
-                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: toolName, arguments: args },
-        }) + "\n");
-    });
-}
-describe("blank query filters", () => {
-    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();
-    });
-    afterEach(() => {
-        mockGitLab.clearCustomHandlers();
-    });
-    const env = () => ({
-        GITLAB_API_URL: `${mockGitLabUrl}/api/v4`,
-        GITLAB_PERSONAL_ACCESS_TOKEN: MOCK_TOKEN,
-    });
-    // Registers a handler that captures the request URL and answers with an empty list
-    function captureRequest(path) {
-        let capturedUrl;
-        mockGitLab.addMockHandler("get", path, (req, res) => {
-            capturedUrl = req.originalUrl;
-            res.json([]);
-        });
-        return () => {
-            assert.ok(capturedUrl, "Mock handler should have received a request");
-            return capturedUrl;
-        };
-    }
-    function searchOf(capturedUrl) {
-        return new URL(capturedUrl, "http://localhost").search;
-    }
-    test("list_labels omits blank filters", async () => {
-        const capturedUrl = captureRequest(`/projects/${TEST_PROJECT_ID}/labels`);
-        const labels = await callTool("list_labels", { project_id: TEST_PROJECT_ID, search: "" }, env());
-        assert.deepStrictEqual(labels, []);
-        assert.strictEqual(searchOf(capturedUrl()), "");
-    });
-    test("list_tags omits blank filters", async () => {
-        const capturedUrl = captureRequest(`/projects/${TEST_PROJECT_ID}/repository/tags`);
-        const tags = await callTool("list_tags", { project_id: TEST_PROJECT_ID, search: "   " }, env());
-        assert.deepStrictEqual(tags, []);
-        assert.strictEqual(searchOf(capturedUrl()), "");
-    });
-    test("list_pipelines omits blank filters", async () => {
-        const capturedUrl = captureRequest(`/projects/${TEST_PROJECT_ID}/pipelines`);
-        const pipelines = await callTool("list_pipelines", { project_id: TEST_PROJECT_ID, ref: "" }, env());
-        assert.deepStrictEqual(pipelines, []);
-        assert.strictEqual(searchOf(capturedUrl()), "");
-    });
-    test("list_deployments omits blank filters", async () => {
-        const capturedUrl = captureRequest(`/projects/${TEST_PROJECT_ID}/deployments`);
-        const deployments = await callTool("list_deployments", { project_id: TEST_PROJECT_ID, environment: "", ref: "\t" }, env());
-        assert.deepStrictEqual(deployments, []);
-        assert.strictEqual(searchOf(capturedUrl()), "");
-    });
-    test("list_environments omits blank filters", async () => {
-        const capturedUrl = captureRequest(`/projects/${TEST_PROJECT_ID}/environments`);
-        const environments = await callTool("list_environments", { project_id: TEST_PROJECT_ID, name: " ", search: "" }, env());
-        assert.deepStrictEqual(environments, []);
-        assert.strictEqual(searchOf(capturedUrl()), "");
-    });
-    test("list_job_artifacts omits blank filters", async () => {
-        const capturedUrl = captureRequest(`/projects/${TEST_PROJECT_ID}/jobs/7/artifacts/tree`);
-        const artifacts = await callTool("list_job_artifacts", { project_id: TEST_PROJECT_ID, job_id: "7", path: "" }, env());
-        assert.deepStrictEqual(artifacts, []);
-        assert.strictEqual(searchOf(capturedUrl()), "");
-    });
-    test("list_events omits blank filters", async () => {
-        const capturedUrl = captureRequest("/events");
-        const events = await callTool("list_events", { action: "", scope: " \t" }, env());
-        assert.deepStrictEqual(events, []);
-        assert.strictEqual(searchOf(capturedUrl()), "");
-    });
-    test("list_project_variables omits blank nested filters", async () => {
-        const capturedUrl = captureRequest(`/projects/${TEST_PROJECT_ID}/variables`);
-        const variables = await callTool("list_project_variables", { project_id: TEST_PROJECT_ID, filter: { environment_scope: "  " } }, env());
-        assert.deepStrictEqual(variables, []);
-        assert.strictEqual(searchOf(capturedUrl()), "");
-    });
-    test("list_labels keeps a non-blank filter", async () => {
-        const capturedUrl = captureRequest(`/projects/${TEST_PROJECT_ID}/labels`);
-        await callTool("list_labels", { project_id: TEST_PROJECT_ID, search: "bug" }, env());
-        const params = new URL(capturedUrl(), "http://localhost").searchParams;
-        assert.deepStrictEqual(params.getAll("search"), ["bug"]);
-    });
-    test("list_project_variables keeps a non-blank nested filter", async () => {
-        const capturedUrl = captureRequest(`/projects/${TEST_PROJECT_ID}/variables`);
-        await callTool("list_project_variables", { project_id: TEST_PROJECT_ID, filter: { environment_scope: "production" } }, env());
-        const params = new URL(capturedUrl(), "http://localhost").searchParams;
-        assert.deepStrictEqual(params.getAll("filter[environment_scope]"), ["production"]);
-    });
-});

package/build/test/test-ci-catalog.js

@@ -1,177 +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 = "mock-ci-catalog-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,
-            },
-        });
-        proc.on("error", reject);
-        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) {
-                reject(new Error(`Process exited with code ${code}: ${errorOutput}`));
-                return;
-            }
-            try {
-                const line = output.split("\n").find(l => l.startsWith("{"));
-                if (!line) {
-                    reject(new Error("No JSON output found"));
-                    return;
-                }
-                const response = JSON.parse(line);
-                if (response.error) {
-                    reject(new Error(response.error.message ?? JSON.stringify(response.error)));
-                    return;
-                }
-                const content = response.result?.content?.[0]?.text;
-                resolve(content ? JSON.parse(content) : response.result);
-            }
-            catch (error) {
-                reject(error);
-            }
-        });
-        proc.stdin?.end(JSON.stringify({
-            jsonrpc: "2.0",
-            id: 1,
-            method: "tools/call",
-            params: { name: toolName, arguments: args },
-        }) + "\n");
-    });
-}
-describe("CI/CD Catalog tools", () => {
-    let mockGitLab;
-    let mockGitLabUrl;
-    const env = () => ({
-        GITLAB_API_URL: `${mockGitLabUrl}/api/v4`,
-        GITLAB_PERSONAL_ACCESS_TOKEN: MOCK_TOKEN,
-    });
-    before(async () => {
-        const port = await findMockServerPort();
-        mockGitLab = new MockGitLabServer({ port, validTokens: [MOCK_TOKEN] });
-        mockGitLab.addRootHandler("post", "/api/graphql", (req, res) => {
-            if (req.body.query.includes("ListCiCatalogResources")) {
-                assert.strictEqual(req.body.variables.search, "docker");
-                res.json({
-                    data: {
-                        ciCatalogResources: {
-                            nodes: [
-                                {
-                                    id: "gid://gitlab/Ci::Catalog::Resource/1",
-                                    name: "Docker",
-                                    description: "Build Docker images",
-                                    fullPath: "components/docker",
-                                    icon: null,
-                                    starCount: 3,
-                                    topics: ["ci"],
-                                    verificationLevel: "UNVERIFIED",
-                                    visibilityLevel: "public",
-                                    webPath: "/components/docker",
-                                    latestReleasedAt: "2026-01-01T00:00:00Z",
-                                    last30DayUsageCount: 7,
-                                },
-                            ],
-                            pageInfo: { hasNextPage: false, endCursor: null },
-                        },
-                    },
-                });
-                return;
-            }
-            res.json({
-                data: {
-                    ciCatalogResource: {
-                        id: "gid://gitlab/Ci::Catalog::Resource/1",
-                        name: "Docker",
-                        description: "Build Docker images",
-                        fullPath: "components/docker",
-                        icon: null,
-                        starCount: 3,
-                        topics: ["ci"],
-                        verificationLevel: "UNVERIFIED",
-                        visibilityLevel: "public",
-                        webPath: "/components/docker",
-                        latestReleasedAt: "2026-01-01T00:00:00Z",
-                        last30DayUsageCount: 7,
-                        versions: {
-                            nodes: [
-                                {
-                                    id: "gid://gitlab/Ci::Catalog::Resources::Version/1",
-                                    name: "1.0.0",
-                                    path: "/components/docker/-/releases/1.0.0",
-                                    createdAt: "2026-01-01T00:00:00Z",
-                                    releasedAt: "2026-01-01T00:00:00Z",
-                                    semver: { major: 1, minor: 0, patch: 0 },
-                                    components: {
-                                        nodes: [
-                                            {
-                                                id: "gid://gitlab/Ci::Catalog::Resources::Component/1",
-                                                name: "build",
-                                                description: "Build an image",
-                                                includePath: "components/docker/build@1.0.0",
-                                                last30DayUsageCount: 4,
-                                                inputs: [
-                                                    {
-                                                        name: "image",
-                                                        description: "Image name",
-                                                        type: "STRING",
-                                                        required: true,
-                                                        default: null,
-                                                        options: null,
-                                                        regex: null,
-                                                    },
-                                                ],
-                                            },
-                                            {
-                                                id: "gid://gitlab/Ci::Catalog::Resources::Component/2",
-                                                name: "scan",
-                                                description: "Scan an image",
-                                                includePath: "components/docker/scan@1.0.0",
-                                                last30DayUsageCount: 2,
-                                                inputs: [],
-                                            },
-                                        ],
-                                        pageInfo: { hasNextPage: false, endCursor: null },
-                                    },
-                                },
-                            ],
-                            pageInfo: { hasNextPage: false, endCursor: null },
-                        },
-                    },
-                },
-            });
-        });
-        await mockGitLab.start();
-        mockGitLabUrl = mockGitLab.getUrl();
-    });
-    after(async () => {
-        await mockGitLab.stop();
-    });
-    test("list_ci_catalog_resources calls GitLab GraphQL", async () => {
-        const result = await callTool("list_ci_catalog_resources", { search: "docker" }, env());
-        const resource = result.data.ciCatalogResources.nodes[0];
-        assert.strictEqual(resource.name, "Docker");
-        assert.strictEqual(resource.fullPath, "components/docker");
-    });
-    test("get_ci_catalog_resource can filter returned components by name", async () => {
-        const result = await callTool("get_ci_catalog_resource", { full_path: "components/docker", component_name: "build" }, env());
-        const components = result.data.ciCatalogResource.versions.nodes[0].components.nodes;
-        assert.strictEqual(components.length, 1);
-        assert.strictEqual(components[0].name, "build");
-        assert.strictEqual(components[0].inputs[0].name, "image");
-    });
-    test("get_ci_catalog_resource rejects empty identity values", async () => {
-        await assert.rejects(() => callTool("get_ci_catalog_resource", { full_path: "" }, env()), /full_path|Too small|minLength|invalid/i);
-    });
-    test("get_ci_catalog_resource rejects multiple identity values", async () => {
-        await assert.rejects(() => callTool("get_ci_catalog_resource", { id: "gid://gitlab/Ci::Catalog::Resource/1", full_path: "components/docker" }, env()), /exactly one|id|full_path/i);
-    });
-});

package/build/test/test-ci-lint.js

@@ -1,191 +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-ci-lint-test-token";
-const TEST_PROJECT_ID = "123";
-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,
-                USE_PIPELINE: "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;
-                    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: { 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");
-    });
-}
-describe("GitLab CI lint tools", () => {
-    let mockGitLab;
-    let mockGitLabUrl;
-    before(async () => {
-        const mockPort = await findMockServerPort();
-        mockGitLab = new MockGitLabServer({
-            port: mockPort,
-            validTokens: [MOCK_TOKEN],
-        });
-        mockGitLab.addMockHandler("post", `/projects/${TEST_PROJECT_ID}/ci/lint`, (req, res) => {
-            assert.strictEqual(req.body.content, "stages: [test]\ntest:\n  script: echo ok");
-            assert.strictEqual(req.body.dry_run, true);
-            assert.strictEqual(req.body.include_jobs, true);
-            assert.strictEqual(req.body.ref, "main");
-            res.json({
-                valid: true,
-                errors: [],
-                warnings: [],
-                merged_yaml: "test:\n  script: echo ok\n",
-                includes: [],
-                jobs: [{ name: "test", stage: "test" }],
-            });
-        });
-        mockGitLab.addMockHandler("get", `/projects/${TEST_PROJECT_ID}/ci/lint`, (req, res) => {
-            assert.strictEqual(req.query.content_ref, "feature/test");
-            assert.strictEqual(req.query.dry_run, "true");
-            assert.strictEqual(req.query.dry_run_ref, "main");
-            assert.strictEqual(req.query.include_jobs, "true");
-            res.json({
-                valid: true,
-                errors: [],
-                warnings: [],
-                merged_yaml: "include-job:\n  script: echo included\n",
-                includes: [{ type: "local", location: "include.yml" }],
-                jobs: [{ name: "include-job", stage: "test" }],
-            });
-        });
-        await mockGitLab.start();
-        mockGitLabUrl = mockGitLab.getUrl();
-    });
-    after(async () => {
-        await mockGitLab.stop();
-    });
-    test("validate_ci_lint posts CI YAML content and returns lint result", async () => {
-        const result = await callTool("validate_ci_lint", {
-            project_id: TEST_PROJECT_ID,
-            content: "stages: [test]\ntest:\n  script: echo ok",
-            dry_run: true,
-            include_jobs: true,
-            ref: "main",
-        }, {
-            GITLAB_API_URL: `${mockGitLabUrl}/api/v4`,
-            GITLAB_PERSONAL_ACCESS_TOKEN: MOCK_TOKEN,
-        });
-        assert.strictEqual(result.valid, true);
-        assert.deepStrictEqual(result.errors, []);
-        assert.strictEqual(result.jobs[0].name, "test");
-    });
-    test("validate_ci_lint surfaces invalid lint responses", async () => {
-        mockGitLab.addMockHandler("post", `/projects/999/ci/lint`, (req, res) => {
-            res.json({
-                valid: false,
-                errors: ["jobs config should contain at least one visible job"],
-                warnings: [],
-            });
-        });
-        const result = await callTool("validate_ci_lint", {
-            project_id: "999",
-            content: ".hidden:\n  script: echo hidden",
-        }, {
-            GITLAB_API_URL: `${mockGitLabUrl}/api/v4`,
-            GITLAB_PERSONAL_ACCESS_TOKEN: MOCK_TOKEN,
-        });
-        assert.strictEqual(result.valid, false);
-        assert.deepStrictEqual(result.errors, ["jobs config should contain at least one visible job"]);
-    });
-    test("validate_project_ci_lint sends GET query parameters", async () => {
-        const result = await callTool("validate_project_ci_lint", {
-            project_id: TEST_PROJECT_ID,
-            content_ref: "feature/test",
-            dry_run: true,
-            dry_run_ref: "main",
-            include_jobs: true,
-        }, {
-            GITLAB_API_URL: `${mockGitLabUrl}/api/v4`,
-            GITLAB_PERSONAL_ACCESS_TOKEN: MOCK_TOKEN,
-        });
-        assert.strictEqual(result.valid, true);
-        assert.strictEqual(result.includes[0].location, "include.yml");
-        assert.strictEqual(result.jobs[0].name, "include-job");
-    });
-    test("CI lint tools are visible by default in read-only mode", 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("validate_ci_lint"));
-        assert.ok(tools.includes("validate_project_ci_lint"));
-    });
-});