@zereight/mcp-gitlab 2.1.68 → 2.1.70

package/build/test/oauth-device-flow-tests.js

@@ -193,6 +193,16 @@ describe("When reading the CLI command", () => {
             assert.equal(getPositionalCliCommand(["node", "/usr/local/bin/tsx", "index.ts", "auth", "--help"]), "auth");
         });
     });
+    describe("with --use-oauth before a curated command", () => {
+        it("should still return mr instead of consuming it as the flag value", () => {
+            assert.equal(getPositionalCliCommand(["node", "index.js", "--use-oauth", "mr", "list"]), "mr");
+        });
+    });
+    describe("with --read-only false before a curated command", () => {
+        it("should skip the boolean literal and return mr", () => {
+            assert.equal(getPositionalCliCommand(["node", "index.js", "--read-only", "false", "mr", "list"]), "mr");
+        });
+    });
     describe("with space-separated --api-url before auth", () => {
         it("should skip the URL value and return auth", () => {
             assert.equal(getPositionalCliCommand([

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/oauth-startup.test.js

@@ -0,0 +1,204 @@
+/**
+ * OAuth startup tests.
+ *
+ * - isAuthInvalidTokenResponse: pure classifier — refresh failures that mean
+ *   "re-login would fix it" vs transient/config errors that must not open a browser.
+ * - ensureOAuthToken: lazy first-use delivery — the caller must receive the
+ *   token even when the on-disk token is still valid (regression: returning
+ *   early on hasValidToken() alone leaves requests unauthenticated).
+ *
+ * Temp token files + a loopback mock for /oauth/token only; no MCP server.
+ * The missing-token and invalid_grant paths start the interactive browser
+ * flow and are deliberately not covered here.
+ */
+import { describe, test, afterEach } from "node:test";
+import assert from "node:assert";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import * as http from "node:http";
+import { GitLabOAuth, ensureOAuthToken, isAuthInvalidTokenResponse } from "../oauth.js";
+const validTokenFile = {
+    access_token: "cached-access-token",
+    refresh_token: "cached-refresh-token",
+    expires_in: 7200,
+    created_at: Date.now(),
+    token_type: "Bearer",
+};
+const expiredTokenFile = {
+    ...validTokenFile,
+    created_at: Date.now() - 10 * 3600 * 1000,
+};
+const tmpDirs = [];
+const servers = [];
+afterEach(async () => {
+    for (const server of servers.splice(0)) {
+        await new Promise(resolve => server.close(() => resolve()));
+    }
+    for (const dir of tmpDirs.splice(0)) {
+        fs.rmSync(dir, { recursive: true, force: true });
+    }
+});
+function makeTokenFile(data) {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "oauth-startup-"));
+    tmpDirs.push(dir);
+    const file = path.join(dir, "token.json");
+    fs.writeFileSync(file, JSON.stringify(data));
+    return file;
+}
+function makeClient(tokenStoragePath, gitlabUrl, extra) {
+    return new GitLabOAuth({
+        clientId: "test-client",
+        redirectUri: "http://127.0.0.1:8888/callback",
+        gitlabUrl,
+        scopes: ["api"],
+        tokenStoragePath,
+        ...extra,
+    });
+}
+async function startTokenServer(handler) {
+    const bodies = [];
+    const server = http.createServer((req, res) => {
+        let body = "";
+        req.on("data", (chunk) => {
+            body += chunk.toString();
+        });
+        req.on("end", () => {
+            bodies.push(body);
+            const { status, json } = handler();
+            res.writeHead(status, { "Content-Type": "application/json" });
+            res.end(JSON.stringify(json));
+        });
+    });
+    servers.push(server);
+    await new Promise(resolve => server.listen(0, "127.0.0.1", () => resolve()));
+    const addr = server.address();
+    assert(addr && typeof addr !== "string");
+    return { url: `http://127.0.0.1:${addr.port}`, bodies };
+}
+describe("isAuthInvalidTokenResponse", () => {
+    test("400 invalid_grant is auth-invalid", () => {
+        assert.strictEqual(isAuthInvalidTokenResponse(400, '{"error":"invalid_grant"}'), true);
+    });
+    test("400 invalid_token is auth-invalid", () => {
+        assert.strictEqual(isAuthInvalidTokenResponse(400, '{"error":"invalid_token"}'), true);
+    });
+    test("401 invalid_grant is auth-invalid", () => {
+        assert.strictEqual(isAuthInvalidTokenResponse(401, '{"error":"invalid_grant"}'), true);
+    });
+    test("400 invalid_client is not auth-invalid (config error)", () => {
+        assert.strictEqual(isAuthInvalidTokenResponse(400, '{"error":"invalid_client"}'), false);
+    });
+    test("400 invalid_request is not auth-invalid (config error)", () => {
+        assert.strictEqual(isAuthInvalidTokenResponse(400, '{"error":"invalid_request"}'), false);
+    });
+    test("500 server_error is not auth-invalid (transient)", () => {
+        assert.strictEqual(isAuthInvalidTokenResponse(500, '{"error":"server_error"}'), false);
+    });
+    test("429 is not auth-invalid (rate limited)", () => {
+        assert.strictEqual(isAuthInvalidTokenResponse(429, '{"error":"invalid_grant"}'), false);
+    });
+    test("non-JSON body is not auth-invalid", () => {
+        assert.strictEqual(isAuthInvalidTokenResponse(400, "gateway timeout"), false);
+    });
+});
+describe("ensureOAuthToken", () => {
+    test("null client is a no-op", async () => {
+        const delivered = [];
+        await ensureOAuthToken(null, null, t => {
+            delivered.push(t);
+        });
+        await ensureOAuthToken(undefined, undefined, t => {
+            delivered.push(t);
+        });
+        assert.deepStrictEqual(delivered, []);
+    });
+    test("first call with valid cached token delivers it without network", async () => {
+        // Closed port: any fetch attempt fails, proving the cached path is network-free.
+        const client = makeClient(makeTokenFile(validTokenFile), "http://127.0.0.1:9");
+        const delivered = [];
+        await ensureOAuthToken(client, null, t => {
+            delivered.push(t);
+        });
+        assert.deepStrictEqual(delivered, ["cached-access-token"]);
+    });
+    test("already-held valid token is not re-delivered", async () => {
+        const client = makeClient(makeTokenFile(validTokenFile), "http://127.0.0.1:9");
+        const delivered = [];
+        await ensureOAuthToken(client, "cached-access-token", t => {
+            delivered.push(t);
+        });
+        assert.deepStrictEqual(delivered, []);
+    });
+    test("expired token refreshes via /oauth/token and persists", async () => {
+        const { url, bodies } = await startTokenServer(() => ({
+            status: 200,
+            json: {
+                access_token: "fresh-token",
+                refresh_token: "fresh-refresh",
+                expires_in: 7200,
+                token_type: "Bearer",
+            },
+        }));
+        const file = makeTokenFile(expiredTokenFile);
+        const client = makeClient(file, url);
+        const delivered = [];
+        await ensureOAuthToken(client, null, t => {
+            delivered.push(t);
+        });
+        assert.deepStrictEqual(delivered, ["fresh-token"]);
+        assert.strictEqual(bodies.length, 1);
+        assert.match(bodies[0], /grant_type=refresh_token/);
+        assert.match(bodies[0], /refresh_token=cached-refresh-token/);
+        const saved = JSON.parse(fs.readFileSync(file, "utf8"));
+        assert.strictEqual(saved.access_token, "fresh-token");
+    });
+    test("transient refresh failure propagates without opening a browser", async () => {
+        const { url } = await startTokenServer(() => ({ status: 500, json: { error: "server_error" } }));
+        const client = makeClient(makeTokenFile(expiredTokenFile), url);
+        const delivered = [];
+        // Rejection (not a browser popup) proves the no-browser path.
+        await assert.rejects(() => ensureOAuthToken(client, null, t => {
+            delivered.push(t);
+        }), /Token refresh failed: 500/);
+        assert.deepStrictEqual(delivered, []);
+    });
+    test("token script resolves once, then fast path holds", async () => {
+        const dir = fs.mkdtempSync(path.join(os.tmpdir(), "oauth-startup-"));
+        tmpDirs.push(dir);
+        const client = makeClient(path.join(dir, "token.json"), "http://127.0.0.1:9", {
+            tokenScript: "echo script-token-1",
+        });
+        const delivered = [];
+        await ensureOAuthToken(client, null, t => {
+            delivered.push(t);
+        });
+        assert.deepStrictEqual(delivered, ["script-token-1"]);
+        await ensureOAuthToken(client, delivered[0], t => {
+            delivered.push(t);
+        });
+        assert.deepStrictEqual(delivered, ["script-token-1"]);
+    });
+    test("concurrent calls coalesce into a single refresh request", async () => {
+        const { url, bodies } = await startTokenServer(() => ({
+            status: 200,
+            json: {
+                access_token: "coalesced-token",
+                refresh_token: "new-refresh",
+                expires_in: 7200,
+                token_type: "Bearer",
+            },
+        }));
+        const file = makeTokenFile(expiredTokenFile);
+        const client = makeClient(file, url);
+        const deliveredA = [];
+        const deliveredB = [];
+        await Promise.all([
+            ensureOAuthToken(client, null, t => deliveredA.push(t)),
+            ensureOAuthToken(client, null, t => deliveredB.push(t)),
+        ]);
+        assert.deepStrictEqual(deliveredA, ["coalesced-token"]);
+        assert.deepStrictEqual(deliveredB, ["coalesced-token"]);
+        assert.strictEqual(bodies.length, 1);
+    });
+});

package/build/test/test-dynamic-project-scope.js

@@ -79,6 +79,7 @@ describe("Dynamic project scope", { concurrency: 1 }, () => {
                     ENABLE_DYNAMIC_PROJECT_SCOPE: "true",
                     ENABLE_STRICT_PROJECT_SCOPE: "true",
                     GITLAB_API_URL: `${mockGitLab.getUrl()}/api/v4`,
+                    GITLAB_TOOLS: "execute_graphql",
                     GITLAB_ALLOWED_PROJECT_IDS: "1,2",
                 },
             });
@@ -286,6 +287,7 @@ describe("Dynamic project scope", { concurrency: 1 }, () => {
                     REMOTE_AUTHORIZATION: "true",
                     ENABLE_DYNAMIC_PROJECT_SCOPE: "true",
                     GITLAB_API_URL: `${mockGitLab.getUrl()}/api/v4`,
+                    GITLAB_TOOLS: "execute_graphql,get_vulnerability",
                 },
             });
             servers.push(server);

package/build/test/test-geteffectiveprojectid.js

@@ -168,6 +168,7 @@ describe('getEffectiveProjectId', { concurrency: 1 }, () => {
                     GITLAB_API_URL: `${mockGitLabUrl}/api/v4`,
                     GITLAB_PROJECT_ID: DEFAULT_PROJECT_ID,
                     GITLAB_READ_ONLY_MODE: 'false',
+                    GITLAB_TOOLSETS: 'all',
                 }
             });
             servers.push(server);
@@ -259,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');
         });
@@ -318,6 +311,7 @@ describe('getEffectiveProjectId', { concurrency: 1 }, () => {
                     GITLAB_PROJECT_ID: DEFAULT_PROJECT_ID,
                     GITLAB_ALLOWED_PROJECT_IDS: DEFAULT_PROJECT_ID,
                     GITLAB_READ_ONLY_MODE: 'true',
+                    GITLAB_TOOLSETS: 'all',
                 }
             });
             servers.push(server);
@@ -484,7 +478,7 @@ describe('getEffectiveProjectId', { concurrency: 1 }, () => {
                     REMOTE_AUTHORIZATION: 'true',
                     GITLAB_API_URL: `${mockGitLabUrl}/api/v4`,
                     GITLAB_PROJECT_ID: DEFAULT_PROJECT_ID,
-                    GITLAB_TOOLSETS: 'variables',
+                    GITLAB_TOOLSETS: 'variables,repositories,groups,projects',
                 }
             });
             servers.push(server);
@@ -582,7 +576,7 @@ describe('getEffectiveProjectId', { concurrency: 1 }, () => {
                     REMOTE_AUTHORIZATION: 'true',
                     GITLAB_API_URL: `${mockGitLabUrl}/api/v4`,
                     GITLAB_ALLOWED_PROJECT_IDS: DEFAULT_PROJECT_ID,
-                    GITLAB_TOOLSETS: 'variables,merge_requests,issues,pipelines',
+                    GITLAB_TOOLSETS: 'variables,merge_requests,issues,pipelines,repositories,groups,projects',
                 }
             });
             servers.push(server);

package/build/test/test-permission-mode.js

@@ -31,6 +31,8 @@ async function launchMcpServer(extraEnv = {}) {
             REMOTE_AUTHORIZATION: "true",
             GITLAB_API_URL: `${mockGitLabUrl}/api/v4`,
             GITLAB_TOOLSETS: "all",
+            // execute_graphql is in no toolset; opt in so the guards under test are reachable.
+            GITLAB_TOOLS: "execute_graphql",
             ...extraEnv,
         },
     });
@@ -280,6 +282,90 @@ describe("Permission Mode", { concurrency: 1 }, () => {
             }
         });
     });
+    describe("call-time enforcement of list filters (modify mode)", () => {
+        const servers = [];
+        after(() => cleanupServers(servers));
+        /** Calls a tool on a fresh client and returns the serialized result, or the error message. */
+        async function callOutcome(server, name, args) {
+            const client = await connectClient(server);
+            try {
+                return JSON.stringify(await client.callTool(name, args));
+            }
+            catch (error) {
+                return error instanceof Error ? error.message : String(error);
+            }
+            finally {
+                await client.disconnect();
+            }
+        }
+        test("rejects a regex-denied tool and an execute_graphql with no GITLAB_TOOLS entry", async () => {
+            const server = await launchMcpServer({
+                GITLAB_PERMISSION_MODE: "modify",
+                GITLAB_TOOLS: "",
+                GITLAB_DENIED_TOOLS_REGEX: "^merge_merge_request$",
+            });
+            servers.push(server);
+            const names = await getToolNames(server);
+            assert.ok(!names.includes("merge_merge_request"), "regex-denied tool must be unlisted");
+            assert.ok(!names.includes("execute_graphql"), "execute_graphql must be unlisted");
+            const merge = await callOutcome(server, "merge_merge_request", {
+                project_id: "1",
+                merge_request_iid: 1,
+            });
+            assert.ok(merge.includes("not available"), `merge_merge_request: ${merge}`);
+            const graphql = await callOutcome(server, "execute_graphql", {
+                query: "query { currentUser { id } }",
+            });
+            assert.ok(graphql.includes("not available"), `execute_graphql: ${graphql}`);
+        });
+        test("policy-hidden tool is unlisted but still callable", async () => {
+            const server = await launchMcpServer({
+                GITLAB_PERMISSION_MODE: "modify",
+                GITLAB_TOOL_POLICY_HIDDEN: "list_issues",
+            });
+            servers.push(server);
+            const names = await getToolNames(server);
+            assert.ok(!names.includes("list_issues"), "hidden tool must be unlisted");
+            const outcome = await callOutcome(server, "list_issues", { project_id: "1" });
+            assert.ok(!outcome.includes("not available"), `hidden tool must stay callable: ${outcome}`);
+        });
+        test("policy-hidden tool that is also regex-denied is rejected", async () => {
+            const server = await launchMcpServer({
+                GITLAB_PERMISSION_MODE: "modify",
+                GITLAB_TOOL_POLICY_HIDDEN: "list_issues",
+                GITLAB_DENIED_TOOLS_REGEX: "^list_issues$",
+            });
+            servers.push(server);
+            const names = await getToolNames(server);
+            assert.ok(!names.includes("list_issues"), "hidden tool must be unlisted");
+            const outcome = await callOutcome(server, "list_issues", { project_id: "1" });
+            assert.ok(outcome.includes("not available"), `regex denial must win over hidden exemption: ${outcome}`);
+        });
+        test("tool outside the enabled toolsets is rejected until discover_tools activates it", async () => {
+            const server = await launchMcpServer({
+                GITLAB_PERMISSION_MODE: "modify",
+                GITLAB_TOOLSETS: "issues",
+            });
+            servers.push(server);
+            const client = await connectClient(server);
+            try {
+                const before = await client
+                    .callTool("list_pipelines", { project_id: "1" })
+                    .then(r => JSON.stringify(r))
+                    .catch((e) => e.message);
+                assert.ok(before.includes("not available"), `before activation: ${before}`);
+                await client.callTool("discover_tools", { category: "pipelines" });
+                const after = await client
+                    .callTool("list_pipelines", { project_id: "1" })
+                    .then(r => JSON.stringify(r))
+                    .catch((e) => e.message);
+                assert.ok(!after.includes("not available"), `after activation: ${after}`);
+            }
+            finally {
+                await client.disconnect();
+            }
+        });
+    });
     describe("readonly mode via GITLAB_PERMISSION_MODE", () => {
         let server;
         const servers = [];

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/tools/denied-regex.js

@@ -0,0 +1,38 @@
+const MAX_PATTERN_LENGTH = 200;
+const NESTED_QUANTIFIER_PATTERN = /(\(.*[+*?].*\)|\[.*\])[+*?]/;
+// Only allow safe characters in tool regex patterns to prevent regex injection (CodeQL)
+const SAFE_PATTERN_CHARS = /^[a-zA-Z0-9_|^$().*+?{}[\]\\:,\s-]+$/;
+export function compileDeniedToolsRegex(pattern) {
+    if (!pattern) {
+        return { regex: undefined, error: undefined };
+    }
+    if (pattern.length > MAX_PATTERN_LENGTH) {
+        return {
+            regex: undefined,
+            error: `GITLAB_DENIED_TOOLS_REGEX pattern exceeds ${MAX_PATTERN_LENGTH} chars. Ignoring.`,
+        };
+    }
+    if (!SAFE_PATTERN_CHARS.test(pattern)) {
+        return {
+            regex: undefined,
+            error: "GITLAB_DENIED_TOOLS_REGEX contains invalid characters. Ignoring.",
+        };
+    }
+    if (NESTED_QUANTIFIER_PATTERN.test(pattern)) {
+        return {
+            regex: undefined,
+            error: "GITLAB_DENIED_TOOLS_REGEX contains potentially unsafe nested quantifiers. Ignoring.",
+        };
+    }
+    try {
+        const regex = new RegExp(pattern);
+        regex.test("sample_tool_name");
+        return { regex, error: undefined };
+    }
+    catch {
+        return {
+            regex: undefined,
+            error: `Invalid GITLAB_DENIED_TOOLS_REGEX pattern: "${pattern}". Ignoring.`,
+        };
+    }
+}