@zereight/mcp-gitlab 2.1.69 → 2.1.70

package/build/test/gitlab-api-tool-errors.test.js

@@ -0,0 +1,112 @@
+import assert from "node:assert/strict";
+import http from "node:http";
+import { describe, test } from "node:test";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { getDefaultEnvironment, StdioClientTransport, } from "@modelcontextprotocol/sdk/client/stdio.js";
+const MASKED_IP = "10.20.30.40";
+async function startServer(t) {
+    const api = http.createServer((req, res) => {
+        res.setHeader("Content-Type", "application/json");
+        if (req.url === "/api/v4/namespaces/missing") {
+            res.statusCode = 404;
+            res.end(JSON.stringify({ message: "Namespace not found", host: MASKED_IP }));
+            return;
+        }
+        if (req.url === "/api/v4/groups/10/members") {
+            res.statusCode = 403;
+            res.end(JSON.stringify({ message: "Forbidden" }));
+            return;
+        }
+        if (req.method === "POST" && req.url === "/api/v4/projects/123/merge_requests") {
+            res.statusCode = 400;
+            res.end(JSON.stringify({ message: "Invalid merge request" }));
+            return;
+        }
+        if (req.url === "/api/v4/namespaces/core/exists") {
+            res.end(JSON.stringify({ exists: true, suggests: [] }));
+            return;
+        }
+        res.statusCode = 404;
+        res.end(JSON.stringify({ message: "Not found" }));
+    });
+    await new Promise((resolve, reject) => {
+        api.once("error", reject);
+        api.listen(0, "127.0.0.1", resolve);
+    });
+    const apiUrl = `http://127.0.0.1:${api.address().port}/api/v4`;
+    const client = new Client({ name: "gitlab-api-tool-error-test", version: "1.0.0" });
+    const transport = new StdioClientTransport({
+        command: process.execPath,
+        args: ["build/index.js"],
+        stderr: "pipe",
+        env: {
+            ...getDefaultEnvironment(),
+            GITLAB_PERSONAL_ACCESS_TOKEN: "test-token",
+            GITLAB_API_URL: apiUrl,
+            GITLAB_PERMISSION_MODE: "modify",
+            GITLAB_TOOLSETS: "projects,merge_requests",
+            GITLAB_MASKING_ENABLED: "true",
+            GITLAB_DISABLE_VERSION_CHECK: "true",
+            LOG_LEVEL: "error",
+        },
+    });
+    transport.stderr?.on("data", () => undefined);
+    t.after(async () => {
+        try {
+            await client.close();
+        }
+        finally {
+            api.closeAllConnections();
+            await new Promise(resolve => api.close(() => resolve()));
+        }
+    });
+    await client.connect(transport);
+    return client;
+}
+function resultText(result) {
+    assert.ok("content" in result && Array.isArray(result.content), "expected tool content");
+    const block = result.content.find((item) => typeof item === "object" &&
+        item !== null &&
+        "type" in item &&
+        item.type === "text" &&
+        "text" in item &&
+        typeof item.text === "string");
+    assert.ok(block, "expected a text tool result");
+    return block.text;
+}
+describe("GitLab API tool errors", () => {
+    test("returns HTTP failures as tool errors and keeps the MCP connection usable", async (t) => {
+        const client = await startServer(t);
+        const notFound = await client.callTool({
+            name: "get_namespace",
+            arguments: { namespace_id: "missing" },
+        });
+        assert.equal(notFound.isError, true);
+        assert.match(resultText(notFound), /GitLab API error: 404 Not Found/);
+        assert.doesNotMatch(resultText(notFound), new RegExp(MASKED_IP.replaceAll(".", "\\.")));
+        assert.match(resultText(notFound), /\[IP address\]/);
+        const forbidden = await client.callTool({
+            name: "list_group_members",
+            arguments: { group_id: "10" },
+        });
+        assert.equal(forbidden.isError, true);
+        assert.match(resultText(forbidden), /GitLab API error: 403 Forbidden/);
+        const invalidMergeRequest = await client.callTool({
+            name: "create_merge_request",
+            arguments: {
+                project_id: "123",
+                title: "Test MR",
+                source_branch: "feature",
+                target_branch: "main",
+            },
+        });
+        assert.equal(invalidMergeRequest.isError, true);
+        assert.match(resultText(invalidMergeRequest), /Invalid request/);
+        const recovery = await client.callTool({
+            name: "verify_namespace",
+            arguments: { path: "core" },
+        });
+        assert.notEqual(recovery.isError, true);
+        assert.deepEqual(JSON.parse(resultText(recovery)), { exists: true, suggests: [] });
+    });
+});

package/build/test/oauth-download-url.test.js

@@ -0,0 +1,157 @@
+import assert from "node:assert/strict";
+import { spawn } from "node:child_process";
+import * as fs from "node:fs";
+import * as net from "node:net";
+import * as os from "node:os";
+import * as path from "node:path";
+import * as url from "node:url";
+import { describe, it } from "node:test";
+// The token key is derived at module load, so the secret must be set before importing it.
+const DOWNLOAD_TOKEN_SECRET = "oauth-download-test-secret";
+process.env.DOWNLOAD_TOKEN_SECRET = DOWNLOAD_TOKEN_SECRET;
+const { decryptDownloadToken } = await import("../utils/download-token.js");
+const __dirname = path.dirname(url.fileURLToPath(import.meta.url));
+const SERVER_ENTRY = path.resolve(__dirname, "../build/index.js");
+const HOST = "127.0.0.1";
+const OAUTH_TOKEN = "oauth-download-test";
+const MCP_ACCESS_TOKEN = "mcp-access-test";
+const STARTUP_TIMEOUT_MS = 15_000;
+const MCP_HEADERS = {
+    "Content-Type": "application/json",
+    Accept: "application/json, text/event-stream",
+    Authorization: `Bearer ${MCP_ACCESS_TOKEN}`,
+};
+function getFreePortAsync() {
+    return new Promise((resolve, reject) => {
+        const probe = net.createServer();
+        probe.on("error", reject);
+        probe.listen(0, HOST, () => {
+            const address = probe.address();
+            if (address === null || typeof address === "string") {
+                probe.close();
+                reject(new Error("probe server is not listening on a TCP port"));
+                return;
+            }
+            probe.close(() => resolve(address.port));
+        });
+    });
+}
+function buildServerEnv(port, tmpDir) {
+    const tokenPath = path.join(tmpDir, "token.json");
+    fs.writeFileSync(tokenPath, JSON.stringify({
+        access_token: OAUTH_TOKEN,
+        refresh_token: "refresh",
+        expires_in: 7200,
+        created_at: Date.now(),
+        token_type: "Bearer",
+    }));
+    const env = {};
+    for (const [key, value] of Object.entries(process.env)) {
+        if (value !== undefined && !key.startsWith("GITLAB_")) {
+            env[key] = value;
+        }
+    }
+    return {
+        ...env,
+        STREAMABLE_HTTP: "true",
+        HOST,
+        PORT: String(port),
+        MCP_SERVER_URL: "",
+        GITLAB_API_URL: `http://${HOST}:1/api/v4`,
+        GITLAB_USE_OAUTH: "true",
+        GITLAB_OAUTH_CLIENT_ID: "client-id",
+        GITLAB_OAUTH_TOKEN_PATH: tokenPath,
+        GITLAB_IS_OLD: "true",
+        USE_PIPELINE: "true",
+        DOWNLOAD_TOKEN_SECRET,
+        STREAMABLE_HTTP_AUTH_TOKEN: MCP_ACCESS_TOKEN,
+    };
+}
+async function waitForServerAsync(port, child) {
+    const deadline = Date.now() + STARTUP_TIMEOUT_MS;
+    while (Date.now() < deadline) {
+        if (child.exitCode !== null) {
+            throw new Error(`server exited early with code ${child.exitCode}`);
+        }
+        const reachable = await new Promise(resolve => {
+            const socket = net.connect(port, HOST);
+            socket.once("connect", () => {
+                socket.destroy();
+                resolve(true);
+            });
+            socket.once("error", () => resolve(false));
+        });
+        if (reachable) {
+            return;
+        }
+        await new Promise(resolve => setTimeout(resolve, 100));
+    }
+    throw new Error("server did not start listening in time");
+}
+async function postMcpAsync(port, body, sessionId) {
+    return fetch(`http://${HOST}:${port}/mcp`, {
+        method: "POST",
+        headers: sessionId ? { ...MCP_HEADERS, "mcp-session-id": sessionId } : MCP_HEADERS,
+        body: JSON.stringify(body),
+    });
+}
+function readJsonRpcResult(sseBody) {
+    const dataLine = sseBody.split("\n").find(line => line.startsWith("data: "));
+    if (dataLine === undefined) {
+        throw new Error(`no SSE data line in response: ${sseBody}`);
+    }
+    return JSON.parse(dataLine.slice("data: ".length));
+}
+function readDownloadUrl(rpc) {
+    const text = JSON.parse(JSON.stringify(rpc)).result?.content?.[0]?.text;
+    if (typeof text !== "string") {
+        throw new Error(`unexpected tool response: ${JSON.stringify(rpc)}`);
+    }
+    const downloadUrl = JSON.parse(text).download_url;
+    if (typeof downloadUrl !== "string") {
+        throw new Error(`no download_url in tool response: ${text}`);
+    }
+    return downloadUrl;
+}
+async function requestDownloadUrlAsync() {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "gitlab-oauth-download-"));
+    const port = await getFreePortAsync();
+    const env = buildServerEnv(port, tmpDir);
+    const child = spawn(process.execPath, [SERVER_ENTRY], { env, stdio: "ignore" });
+    try {
+        await waitForServerAsync(port, child);
+        const init = await postMcpAsync(port, {
+            jsonrpc: "2.0",
+            id: 1,
+            method: "initialize",
+            params: {
+                protocolVersion: "2025-03-26",
+                capabilities: {},
+                clientInfo: { name: "oauth-download-url-test", version: "1.0" },
+            },
+        });
+        const sessionId = init.headers.get("mcp-session-id") ?? undefined;
+        const call = await postMcpAsync(port, {
+            jsonrpc: "2.0",
+            id: 2,
+            method: "tools/call",
+            params: { name: "download_job_artifacts", arguments: { project_id: "g/p", job_id: "1" } },
+        }, sessionId);
+        return readDownloadUrl(readJsonRpcResult(await call.text()));
+    }
+    finally {
+        child.kill("SIGKILL");
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    }
+}
+describe("When a remote server builds a download URL with a stored OAuth token", () => {
+    describe("with GITLAB_IS_OLD enabled", () => {
+        it("should embed the token as a bearer credential", async () => {
+            const downloadUrl = await requestDownloadUrlAsync();
+            const embedded = new URL(downloadUrl).searchParams.get("_token");
+            const decrypted = embedded === null ? null : decryptDownloadToken(embedded);
+            assert.equal(decrypted?.header, "Authorization");
+            assert.equal(decrypted?.token, `Bearer ${OAUTH_TOKEN}`);
+        });
+    });
+});

package/build/test/test-geteffectiveprojectid.js

@@ -260,35 +260,27 @@ describe('getEffectiveProjectId', { concurrency: 1 }, () => {
         });
         test('should not fall back from bare numeric project IDs to groups', async () => {
             group789Requested = false;
-            let didThrow = false;
-            try {
-                await client.callTool('list_work_items', {
-                    project_id: '789',
-                });
-            }
-            catch (error) {
-                didThrow = true;
-                assert.ok(error instanceof Error);
-                assert.ok(error.message.includes('404'), 'Should surface the project 404');
-            }
-            assert.ok(didThrow, 'Should have failed on the project 404');
+            const result = await client.callTool('list_work_items', {
+                project_id: '789',
+            });
+            assert.strictEqual(result.isError, true, 'Should return the project 404 as a tool error');
+            assert.ok(result.content, 'Should have error content');
+            const content = result.content[0];
+            assert.ok('text' in content, 'Error content should have text');
+            assert.ok(content.text.includes('404'), 'Should surface the project 404');
             assert.strictEqual(group789Requested, false, 'Should not request /groups/789');
             console.log('  ✓ Bare numeric ID 789 did not fall back to /groups/789');
         });
         test('should not fall back from explicit numeric project IDs to groups', async () => {
             group789Requested = false;
-            let didThrow = false;
-            try {
-                await client.callTool('list_work_items', {
-                    project_id: 'project:789',
-                });
-            }
-            catch (error) {
-                didThrow = true;
-                assert.ok(error instanceof Error);
-                assert.ok(error.message.includes('404'), 'Should surface the project 404');
-            }
-            assert.ok(didThrow, 'Should have failed on the project 404');
+            const result = await client.callTool('list_work_items', {
+                project_id: 'project:789',
+            });
+            assert.strictEqual(result.isError, true, 'Should return the project 404 as a tool error');
+            assert.ok(result.content, 'Should have error content');
+            const content = result.content[0];
+            assert.ok('text' in content, 'Error content should have text');
+            assert.ok(content.text.includes('404'), 'Should surface the project 404');
             assert.strictEqual(group789Requested, false, 'Should not request /groups/789');
             console.log('  ✓ Explicit project:789 did not fall back to /groups/789');
         });

package/build/test/test-pipeline-schedules.js

@@ -255,7 +255,9 @@ describe("Pipeline schedule tools", () => {
         assert.strictEqual(result.inputs[0].name, "deploy_strategy");
     });
     test("get_pipeline_schedule surfaces a 404 as an error", async () => {
-        await assert.rejects(() => callToolJson("get_pipeline_schedule", { project_id: TEST_PROJECT_ID, pipeline_schedule_id: MISSING_SCHEDULE_ID }, baseEnv), /404/);
+        const result = await callTool("get_pipeline_schedule", { project_id: TEST_PROJECT_ID, pipeline_schedule_id: MISSING_SCHEDULE_ID }, baseEnv);
+        assert.strictEqual(result.isError, true);
+        assert.match(result.content?.[0]?.text ?? "", /404/);
     });
     test("list_pipeline_schedule_pipelines returns the triggered pipelines", async () => {
         const result = await callToolJson("list_pipeline_schedule_pipelines", { project_id: TEST_PROJECT_ID, pipeline_schedule_id: TEST_SCHEDULE_ID }, baseEnv);

package/build/test/utils/url.test.js

@@ -1,6 +1,19 @@
 import assert from "node:assert/strict";
 import { describe, test } from "node:test";
-import { encodeGitLabPath, encodeGitLabPathSegment, normalizeGitLabApiUrl, } from "../../utils/url.js";
+import { encodeGitLabPath, encodeGitLabPathSegment, isCleartextRemoteUrl, normalizeGitLabApiUrl, } from "../../utils/url.js";
+describe("When isCleartextRemoteUrl runs", () => {
+    test("should flag http to a remote host", () => {
+        assert.equal(isCleartextRemoteUrl("http://gitlab.example.com/api/v4"), true);
+    });
+    test("should allow https", () => {
+        assert.equal(isCleartextRemoteUrl("https://gitlab.example.com/api/v4"), false);
+    });
+    test("should allow http to loopback hosts", () => {
+        assert.equal(isCleartextRemoteUrl("http://127.0.0.1:8080/api/v4"), false);
+        assert.equal(isCleartextRemoteUrl("http://localhost/api/v4"), false);
+        assert.equal(isCleartextRemoteUrl("http://[::1]:3000/api/v4"), false);
+    });
+});
 describe("When normalizeGitLabApiUrl runs", () => {
     test("should default to gitlab.com", () => {
         assert.equal(normalizeGitLabApiUrl(""), "https://gitlab.com/api/v4");

package/build/utils/url.js

@@ -17,6 +17,21 @@ export function normalizeGitLabApiUrl(url) {
     }
     return normalizedUrl;
 }
+const LOOPBACK_HOSTNAMES = new Set(["localhost", "127.0.0.1", "[::1]"]);
+/**
+ * True when the URL is plain `http://` to a non-loopback host, i.e. credentials sent
+ * to it would cross the network in cleartext. Unparseable URLs return false (they are
+ * rejected by the config validation instead).
+ */
+export function isCleartextRemoteUrl(url) {
+    try {
+        const parsed = new URL(url);
+        return parsed.protocol === "http:" && !LOOPBACK_HOSTNAMES.has(parsed.hostname);
+    }
+    catch {
+        return false;
+    }
+}
 /**
  * Dot segments anywhere in a decoded value, including after a percent-encoded
  * separator ("..%2F..%2Fuser" decodes to a path-traversal sequence).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zereight/mcp-gitlab",
-  "version": "2.1.69",
+  "version": "2.1.70",
   "mcpName": "io.github.zereight/gitlab-mcp",
   "description": "GitLab MCP server for projects, merge requests, issues, pipelines, wiki, releases, and more",
   "keywords": [