@zereight/mcp-gitlab 2.1.63 → 2.1.64

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

@@ -0,0 +1,145 @@
+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";
+const TEST_GROUP_ID = "my-group";
+// Milestone tools live in the non-default "milestones" toolset
+const TOOLSET_ENV = { GITLAB_TOOLSETS: "milestones" };
+// 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("milestone list iids 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();
+    });
+    const env = () => ({
+        GITLAB_API_URL: `${mockGitLabUrl}/api/v4`,
+        GITLAB_PERSONAL_ACCESS_TOKEN: MOCK_TOKEN,
+    });
+    test("omits an empty iids filter for list_milestones", async () => {
+        let capturedUrl;
+        mockGitLab.addMockHandler("get", `/projects/${TEST_PROJECT_ID}/milestones`, (req, res) => {
+            capturedUrl = req.originalUrl;
+            res.json([]);
+        });
+        try {
+            const milestones = await callTool("list_milestones", { project_id: TEST_PROJECT_ID, iids: [] }, env());
+            assert.deepStrictEqual(milestones, []);
+            assert.ok(capturedUrl, "Mock handler should have received a request");
+            assert.strictEqual(new URL(capturedUrl, "http://localhost").search, "", "An empty iids array should not be serialized as `iids=`");
+        }
+        finally {
+            mockGitLab.clearCustomHandlers();
+        }
+    });
+    test("forwards non-empty iids in bracket-array form", async () => {
+        let capturedUrl;
+        mockGitLab.addMockHandler("get", `/projects/${TEST_PROJECT_ID}/milestones`, (req, res) => {
+            capturedUrl = req.originalUrl;
+            res.json([]);
+        });
+        try {
+            await callTool("list_milestones", { project_id: TEST_PROJECT_ID, iids: [1, 2] }, env());
+            assert.ok(capturedUrl, "Mock handler should have received a request");
+            const params = new URL(capturedUrl, "http://localhost").searchParams;
+            assert.deepStrictEqual(params.getAll("iids[]"), ["1", "2"]);
+        }
+        finally {
+            mockGitLab.clearCustomHandlers();
+        }
+    });
+    test("omits blank milestone filters", async () => {
+        let capturedUrl;
+        mockGitLab.addMockHandler("get", `/projects/${TEST_PROJECT_ID}/milestones`, (req, res) => {
+            capturedUrl = req.originalUrl;
+            res.json([]);
+        });
+        try {
+            await callTool("list_milestones", { project_id: TEST_PROJECT_ID, iids: [], title: "  ", search: "" }, env());
+            assert.ok(capturedUrl, "Mock handler should have received a request");
+            assert.strictEqual(new URL(capturedUrl, "http://localhost").search, "", "Blank milestone filters should not be serialized");
+        }
+        finally {
+            mockGitLab.clearCustomHandlers();
+        }
+    });
+    test("omits an empty iids filter for list_group_milestones", async () => {
+        let capturedUrl;
+        mockGitLab.addMockHandler("get", `/groups/${TEST_GROUP_ID}/milestones`, (req, res) => {
+            capturedUrl = req.originalUrl;
+            res.json([]);
+        });
+        try {
+            const milestones = await callTool("list_group_milestones", { group_id: TEST_GROUP_ID, iids: [], state: "active" }, env());
+            assert.deepStrictEqual(milestones, []);
+            assert.ok(capturedUrl, "Mock handler should have received a request");
+            const params = new URL(capturedUrl, "http://localhost").searchParams;
+            assert.equal(params.has("iids"), false, "An empty iids array should not be serialized as `iids=`");
+            assert.deepStrictEqual(params.getAll("iids[]"), []);
+            assert.deepStrictEqual(params.getAll("state"), ["active"]);
+        }
+        finally {
+            mockGitLab.clearCustomHandlers();
+        }
+    });
+});

package/build/test/utils/tool-args.test.js

@@ -1,6 +1,6 @@
 import assert from "node:assert/strict";
 import { describe, test } from "node:test";
-import { cleanMutuallyExclusiveIdUsernameOptions, LIST_MERGE_REQUESTS_ID_USERNAME_PAIRS, sanitizeToolArguments, } from "../../utils/tool-args.js";
+import { appendFilterParam, appendFilterParams, cleanMutuallyExclusiveIdUsernameOptions, dropBlankArrayEntries, isBlankFilterValue, LIST_MERGE_REQUESTS_ID_USERNAME_PAIRS, sanitizeToolArguments, } from "../../utils/tool-args.js";
 describe("When sanitizeToolArguments runs", () => {
     describe("with top-level null optionals", () => {
         test("should omit null and undefined keys for generic tools", () => {
@@ -120,3 +120,59 @@ describe("When cleanMutuallyExclusiveIdUsernameOptions runs", () => {
         });
     });
 });
+describe("When dropBlankArrayEntries runs", () => {
+    test("should drop blank string entries and keep meaningful ones", () => {
+        assert.deepEqual(dropBlankArrayEntries(["", "  ", "bug"]), ["bug"]);
+        assert.deepEqual(dropBlankArrayEntries(["\t", "alice", ""]), ["alice"]);
+    });
+    test("should leave non-array values untouched", () => {
+        assert.equal(dropBlankArrayEntries("bug"), "bug");
+        assert.equal(dropBlankArrayEntries("  "), "  ");
+        assert.equal(dropBlankArrayEntries(undefined), undefined);
+        assert.equal(dropBlankArrayEntries(false), false);
+    });
+    test("should keep non-string array entries", () => {
+        assert.deepEqual(dropBlankArrayEntries([0, "bug", false]), [0, "bug", false]);
+    });
+});
+describe("When isBlankFilterValue runs", () => {
+    test("should treat undefined, blank strings and empty arrays as blank", () => {
+        assert.equal(isBlankFilterValue(undefined), true);
+        assert.equal(isBlankFilterValue(""), true);
+        assert.equal(isBlankFilterValue(" \t\n"), true);
+        assert.equal(isBlankFilterValue([]), true);
+    });
+    test("should keep meaningful values, including false and zero", () => {
+        assert.equal(isBlankFilterValue("bug"), false);
+        assert.equal(isBlankFilterValue(["bug"]), false);
+        assert.equal(isBlankFilterValue(0), false);
+        assert.equal(isBlankFilterValue(false), false);
+    });
+});
+describe("When appendFilterParams runs", () => {
+    test("should omit blank scalars, blank array entries and empty arrays", () => {
+        const searchParams = new URLSearchParams();
+        appendFilterParams(searchParams, {
+            search: "",
+            ref: "  ",
+            labels: ["", "bug"],
+            iids: [],
+            omitted: undefined,
+        });
+        assert.deepEqual([...searchParams.entries()], [["labels", "bug"]]);
+    });
+    test("should keep booleans, zero and non-blank values", () => {
+        const searchParams = new URLSearchParams();
+        appendFilterParams(searchParams, { with_labels_details: false, page: 0, search: "bug" });
+        assert.deepEqual([...searchParams.entries()], [
+            ["with_labels_details", "false"],
+            ["page", "0"],
+            ["search", "bug"],
+        ]);
+    });
+    test("should append a single parameter without dropping a meaningful value", () => {
+        const searchParams = new URLSearchParams();
+        appendFilterParam(searchParams, "filter[environment_scope]", "production");
+        assert.deepEqual([...searchParams.entries()], [["filter[environment_scope]", "production"]]);
+    });
+});

package/build/utils/tool-args.js

@@ -20,6 +20,41 @@ export function sanitizeToolArguments(toolName, args) {
     }
     return result;
 }
+/**
+ * Drop blank string entries inside array filters so ["", "bug"] behaves like the scalar blank guard.
+ */
+export function dropBlankArrayEntries(value) {
+    if (!Array.isArray(value)) {
+        return value;
+    }
+    return value.filter(item => !(typeof item === "string" && item.trim() === ""));
+}
+/**
+ * Blank filters must be omitted entirely instead of being serialized as empty query parameters
+ * such as `labels=`, `labels[]=` or `iids=`.
+ */
+export function isBlankFilterValue(value) {
+    return (value === undefined ||
+        (typeof value === "string" && value.trim() === "") ||
+        (Array.isArray(value) && value.length === 0));
+}
+/**
+ * Append one query parameter, skipping blank filters and blank entries inside arrays.
+ * Booleans serialize as `true`/`false`, matching the inline branches this replaces.
+ */
+export function appendFilterParam(searchParams, key, value) {
+    const normalized = dropBlankArrayEntries(value);
+    if (isBlankFilterValue(normalized)) {
+        return;
+    }
+    searchParams.append(key, String(normalized));
+}
+/** Append every option as a query parameter while dropping blank filters. */
+export function appendFilterParams(searchParams, options) {
+    for (const [key, value] of Object.entries(options)) {
+        appendFilterParam(searchParams, key, value);
+    }
+}
 /** Pairs where GitLab rejects sending both *_id and *_username query params. */
 export const LIST_ISSUES_ID_USERNAME_PAIRS = [
     ["author_id", "author_username"],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zereight/mcp-gitlab",
-  "version": "2.1.63",
+  "version": "2.1.64",
   "mcpName": "io.github.zereight/gitlab-mcp",
   "description": "GitLab MCP server for projects, merge requests, issues, pipelines, wiki, releases, and more",
   "keywords": [
@@ -65,6 +65,7 @@
     "lint": "eslint . --ext .ts",
     "check:runtime-deps": "node scripts/check-runtime-deps.mjs",
     "check:skill-sync": "tsx scripts/check-skill-sync.ts",
+    "docs:tools": "tsx scripts/generate-tool-docs.ts && tsx scripts/generate-tool-coverage.ts",
     "lint:fix": "eslint . --ext .ts --fix",
     "release": "bash scripts/release.sh",
     "release:mcp-registry": "bash scripts/publish_mcp_registry.sh",