@zereight/mcp-gitlab 2.1.7 → 2.1.9

package/build/test/schema-tests.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env ts-node
-import { GetFileContentsSchema, GitLabFileContentSchema, GitLabRepositorySchema, CreatePipelineSchema, CreateIssueNoteSchema, CreateMergeRequestEmojiReactionSchema, CreateIssueEmojiReactionSchema, DeleteMergeRequestEmojiReactionSchema, DeleteIssueEmojiReactionSchema, CreateWorkItemEmojiReactionSchema, CreateWorkItemNoteEmojiReactionSchema, CreateIssueSchema, ListIssuesSchema, ListMergeRequestsSchema, GitLabTreeItemSchema, GetMergeRequestSchema, GetRepositoryTreeSchema } from '../schemas.js';
+import { GetFileContentsSchema, GitLabFileContentSchema, GitLabRepositorySchema, CreatePipelineSchema, CreateCommitStatusSchema, ListCommitStatusesSchema, CreateIssueNoteSchema, CreateMergeRequestEmojiReactionSchema, CreateIssueEmojiReactionSchema, DeleteMergeRequestEmojiReactionSchema, DeleteIssueEmojiReactionSchema, CreateWorkItemEmojiReactionSchema, CreateWorkItemNoteEmojiReactionSchema, CreateIssueSchema, ListIssuesSchema, ListMergeRequestsSchema, GitLabMergeRequestSchema, GitLabTreeItemSchema, GetMergeRequestSchema, GetRepositoryTreeSchema } from '../schemas.js';
 function runGetFileContentsSchemaTests() {
     console.log('🧪 Testing GetFileContentsSchema...');
     const cases = [
@@ -298,6 +298,142 @@ function runCreatePipelineSchemaTests() {
     console.log(`\nResults: ${passed} passed, ${failed} failed`);
     return { passed, failed };
 }
+function runCommitStatusSchemaTests() {
+    console.log('\n🧪 Testing Commit Status Schemas...');
+    const cases = [
+        {
+            name: 'schema:create_commit_status:minimal-required-fields',
+            schema: CreateCommitStatusSchema,
+            input: { project_id: 'my/project', sha: 'abc123', state: 'success' },
+            expected: { project_id: 'my/project', sha: 'abc123', state: 'success' }
+        },
+        {
+            name: 'schema:create_commit_status:with-optional-fields',
+            schema: CreateCommitStatusSchema,
+            input: {
+                project_id: 'my/project',
+                sha: 'abc123',
+                state: 'failed',
+                name: 'external/check',
+                target_url: 'https://ci.example.com/build/1',
+                description: 'External check failed',
+                coverage: '87.5',
+                pipeline_id: '42'
+            },
+            expected: {
+                project_id: 'my/project',
+                sha: 'abc123',
+                state: 'failed',
+                name: 'external/check',
+                target_url: 'https://ci.example.com/build/1',
+                description: 'External check failed',
+                coverage: 87.5,
+                pipeline_id: 42
+            }
+        },
+        {
+            name: 'schema:create_commit_status:context-alias',
+            schema: CreateCommitStatusSchema,
+            input: { project_id: 123, sha: 'abc123', state: 'pending', context: 'external/check' },
+            expected: { project_id: '123', sha: 'abc123', state: 'pending', context: 'external/check' }
+        },
+        {
+            name: 'schema:create_commit_status:reject-invalid-state',
+            schema: CreateCommitStatusSchema,
+            input: { project_id: 'my/project', sha: 'abc123', state: 'passing' },
+            shouldFail: true
+        },
+        {
+            name: 'schema:create_commit_status:reject-missing-state',
+            schema: CreateCommitStatusSchema,
+            input: { project_id: 'my/project', sha: 'abc123' },
+            shouldFail: true
+        },
+        {
+            name: 'schema:list_commit_statuses:filters',
+            schema: ListCommitStatusesSchema,
+            input: {
+                project_id: 'my/project',
+                sha: 'abc123',
+                ref: 'main',
+                name: 'external/check',
+                pipeline_id: '42',
+                order_by: 'pipeline_id',
+                sort: 'desc',
+                all: 'true',
+                page: '2',
+                per_page: '50'
+            },
+            expected: {
+                project_id: 'my/project',
+                sha: 'abc123',
+                ref: 'main',
+                name: 'external/check',
+                pipeline_id: 42,
+                order_by: 'pipeline_id',
+                sort: 'desc',
+                all: true,
+                page: 2,
+                per_page: 50
+            }
+        },
+        {
+            name: 'schema:list_commit_statuses:all-false-string',
+            schema: ListCommitStatusesSchema,
+            input: { project_id: 'my/project', sha: 'abc123', all: 'false' },
+            expected: { project_id: 'my/project', sha: 'abc123', all: false }
+        },
+        {
+            name: 'schema:list_commit_statuses:reject-invalid-all-string',
+            schema: ListCommitStatusesSchema,
+            input: { project_id: 'my/project', sha: 'abc123', all: 'yes' },
+            shouldFail: true
+        }
+    ];
+    let passed = 0;
+    let failed = 0;
+    cases.forEach(testCase => {
+        const result = {
+            name: testCase.name,
+            status: 'failed'
+        };
+        const parsed = testCase.schema.safeParse(testCase.input);
+        if (testCase.shouldFail) {
+            if (parsed.success) {
+                result.error = 'Expected schema validation to fail';
+            }
+            else {
+                result.status = 'passed';
+            }
+        }
+        else if (parsed.success) {
+            const expected = testCase.expected || {};
+            const matches = Object.entries(expected).every(([key, value]) => {
+                const actual = parsed.data[key];
+                return JSON.stringify(actual) === JSON.stringify(value);
+            });
+            if (matches) {
+                result.status = 'passed';
+            }
+            else {
+                result.error = `Unexpected parsed result: ${JSON.stringify(parsed.data)}`;
+            }
+        }
+        else {
+            result.error = parsed.error?.message || 'Schema validation failed';
+        }
+        if (result.status === 'passed') {
+            passed++;
+            console.log(`✅ ${result.name}`);
+        }
+        else {
+            failed++;
+            console.log(`❌ ${result.name}: ${result.error}`);
+        }
+    });
+    console.log(`\nResults: ${passed} passed, ${failed} failed`);
+    return { passed, failed };
+}
 function runCreateIssueNoteSchemaTests() {
     console.log('\n🧪 Testing CreateIssueNoteSchema...');
     const cases = [
@@ -448,6 +584,93 @@ function runGetMergeRequestSchemaTests() {
     console.log(`\nResults: ${passed} passed, ${failed} failed`);
     return { passed, failed };
 }
+function runGitLabMergeRequestSchemaTests() {
+    console.log('\n🧪 Testing GitLabMergeRequestSchema...');
+    const baseMergeRequest = {
+        id: '1001',
+        iid: '42',
+        project_id: '123',
+        title: 'Add milestone exposure',
+        description: 'Expose MR milestone',
+        state: 'opened',
+        author: {
+            id: '1',
+            username: 'octocat',
+            name: 'Octo Cat',
+            avatar_url: null,
+            web_url: 'https://gitlab.example.com/octocat',
+        },
+        assignees: [],
+        reviewers: [],
+        source_branch: 'feature/milestone',
+        target_branch: 'main',
+        web_url: 'https://gitlab.example.com/group/project/-/merge_requests/42',
+        created_at: '2026-05-07T00:00:00.000Z',
+        updated_at: '2026-05-07T00:00:00.000Z',
+        merged_at: null,
+        closed_at: null,
+        merge_commit_sha: null,
+    };
+    const cases = [
+        {
+            name: 'schema:gitlab_merge_request:preserves-milestone',
+            input: {
+                ...baseMergeRequest,
+                milestone: {
+                    id: '5',
+                    iid: '2',
+                    title: 'v1.0',
+                    description: 'Version 1.0',
+                    state: 'active',
+                    web_url: 'https://gitlab.example.com/group/project/-/milestones/2',
+                },
+            },
+            validate: (data) => data.milestone?.title === 'v1.0' &&
+                data.milestone?.id === '5' &&
+                data.milestone?.iid === '2',
+        },
+        {
+            name: 'schema:gitlab_merge_request:allows-null-milestone',
+            input: {
+                ...baseMergeRequest,
+                milestone: null,
+            },
+            validate: (data) => data.milestone === null,
+        },
+        {
+            name: 'schema:gitlab_merge_request:allows-omitted-milestone',
+            input: {
+                ...baseMergeRequest,
+            },
+            validate: (data) => data.milestone === undefined,
+        },
+    ];
+    let passed = 0;
+    let failed = 0;
+    cases.forEach(testCase => {
+        const result = { name: testCase.name, status: 'failed' };
+        const parsed = GitLabMergeRequestSchema.safeParse(testCase.input);
+        if (parsed.success && testCase.validate(parsed.data)) {
+            result.status = 'passed';
+        }
+        else if (parsed.success) {
+            result.error = `Unexpected parsed result: ${JSON.stringify(parsed.data)}`;
+        }
+        else {
+            result.error = parsed.error?.message || 'Schema validation failed';
+        }
+        if (result.status === 'passed') {
+            passed++;
+            console.log(`✅ ${result.name}`);
+        }
+        else {
+            failed++;
+            console.log(`❌ ${result.name}: ${result.error}`);
+        }
+    });
+    console.log(`\nResults: ${passed} passed, ${failed} failed`);
+    return { passed, failed };
+}
 function runEmojiReactionSchemaTests() {
     console.log('\n🧪 Testing Emoji Reaction Schemas...');
     const cases = [
@@ -778,15 +1001,17 @@ if (import.meta.url === `file://${process.argv[1]}`) {
     const getFileContentsResult = runGetFileContentsSchemaTests();
     const fileContentResult = runGitLabFileContentSchemaTests();
     const createPipelineResult = runCreatePipelineSchemaTests();
+    const commitStatusResult = runCommitStatusSchemaTests();
     const createIssueNoteResult = runCreateIssueNoteSchemaTests();
     const getMergeRequestResult = runGetMergeRequestSchemaTests();
+    const gitLabMergeRequestResult = runGitLabMergeRequestSchemaTests();
     const emojiReactionResult = runEmojiReactionSchemaTests();
     const repositorySchemaResult = runGitLabRepositorySchemaTests();
     const labelsCoercionResult = runLabelsCoercionSchemaTests();
     const treeItemResult = runGitLabTreeItemSchemaTests();
     const repositoryTreeResult = runGetRepositoryTreeSchemaTests();
-    const totalPassed = getFileContentsResult.passed + fileContentResult.passed + createPipelineResult.passed + createIssueNoteResult.passed + getMergeRequestResult.passed + emojiReactionResult.passed + repositorySchemaResult.passed + labelsCoercionResult.passed + treeItemResult.passed + repositoryTreeResult.passed;
-    const totalFailed = getFileContentsResult.failed + fileContentResult.failed + createPipelineResult.failed + createIssueNoteResult.failed + getMergeRequestResult.failed + emojiReactionResult.failed + repositorySchemaResult.failed + labelsCoercionResult.failed + treeItemResult.failed + repositoryTreeResult.failed;
+    const totalPassed = getFileContentsResult.passed + fileContentResult.passed + createPipelineResult.passed + commitStatusResult.passed + createIssueNoteResult.passed + getMergeRequestResult.passed + gitLabMergeRequestResult.passed + emojiReactionResult.passed + repositorySchemaResult.passed + labelsCoercionResult.passed + treeItemResult.passed + repositoryTreeResult.passed;
+    const totalFailed = getFileContentsResult.failed + fileContentResult.failed + createPipelineResult.failed + commitStatusResult.failed + createIssueNoteResult.failed + getMergeRequestResult.failed + gitLabMergeRequestResult.failed + emojiReactionResult.failed + repositorySchemaResult.failed + labelsCoercionResult.failed + treeItemResult.failed + repositoryTreeResult.failed;
     console.log(`\nTotal Results: ${totalPassed} passed, ${totalFailed} failed`);
     if (totalFailed > 0) {
         process.exit(1);

package/build/test/streamable-http-static-token-auth.test.js

@@ -0,0 +1,154 @@
+import assert from "node:assert/strict";
+import { spawn } from "node:child_process";
+import { once } from "node:events";
+import { afterEach, describe, test } from "node:test";
+import * as path from "node:path";
+import { findAvailablePort } from "./utils/server-launcher.js";
+const ERROR_MESSAGE = "STREAMABLE_HTTP=true/--streamable-http with GITLAB_PERSONAL_ACCESS_TOKEN/--token or GITLAB_JOB_TOKEN/--job-token requires REMOTE_AUTHORIZATION=true/--remote-auth=true or GITLAB_MCP_OAUTH=true/--mcp-oauth=true";
+const HOST = process.env.HOST || "127.0.0.1";
+const SERVER_PATH = path.resolve(process.cwd(), "build/index.js");
+const running = new Set();
+function startServer(env, port) {
+    const child = spawn("node", [SERVER_PATH], {
+        env: {
+            ...process.env,
+            GITLAB_API_URL: "https://gitlab.example.com",
+            HOST,
+            PORT: String(port),
+            STREAMABLE_HTTP: "true",
+            REMOTE_AUTHORIZATION: "false",
+            GITLAB_MCP_OAUTH: "false",
+            GITLAB_USE_OAUTH: "false",
+            GITLAB_PERSONAL_ACCESS_TOKEN: "",
+            GITLAB_JOB_TOKEN: "",
+            GITLAB_AUTH_COOKIE_PATH: "",
+            MCP_SERVER_URL: "",
+            GITLAB_OAUTH_APP_ID: "",
+            ...env,
+        },
+        stdio: ["ignore", "pipe", "pipe"],
+    });
+    running.add(child);
+    child.once("exit", () => running.delete(child));
+    return child;
+}
+async function waitForExit(child, timeoutMs = 5000) {
+    let output = "";
+    child.stdout?.on("data", chunk => {
+        output += chunk.toString();
+    });
+    child.stderr?.on("data", chunk => {
+        output += chunk.toString();
+    });
+    let timeoutHandle;
+    const timeout = new Promise((_, reject) => {
+        timeoutHandle = setTimeout(() => reject(new Error(`server did not exit within ${timeoutMs}ms`)), timeoutMs);
+    });
+    try {
+        const [code] = (await Promise.race([once(child, "exit"), timeout]));
+        return { code, output };
+    }
+    finally {
+        clearTimeout(timeoutHandle);
+    }
+}
+async function waitForHealth(port, timeoutMs = 5000) {
+    const deadline = Date.now() + timeoutMs;
+    let lastError;
+    while (Date.now() < deadline) {
+        try {
+            const response = await fetch(`http://${HOST}:${port}/health`);
+            if (response.ok)
+                return;
+        }
+        catch (error) {
+            lastError = error;
+        }
+        await new Promise(resolve => setTimeout(resolve, 100));
+    }
+    throw new Error(`server did not become healthy: ${String(lastError)}`);
+}
+async function postMcpWithoutAuth(port) {
+    return fetch(`http://${HOST}:${port}/mcp`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            Accept: "application/json, text/event-stream",
+        },
+        body: JSON.stringify({
+            jsonrpc: "2.0",
+            id: 1,
+            method: "initialize",
+            params: {
+                protocolVersion: "2025-03-26",
+                capabilities: {},
+                clientInfo: { name: "static-token-auth-test", version: "1.0.0" },
+            },
+        }),
+    });
+}
+async function postMcpWithSessionWithoutAuth(port, sessionId) {
+    return fetch(`http://${HOST}:${port}/mcp`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            Accept: "application/json, text/event-stream",
+            "Mcp-Session-Id": sessionId,
+        },
+        body: JSON.stringify({
+            jsonrpc: "2.0",
+            id: 2,
+            method: "tools/list",
+            params: {},
+        }),
+    });
+}
+afterEach(() => {
+    for (const child of running) {
+        if (!child.killed)
+            child.kill("SIGTERM");
+    }
+    running.clear();
+});
+describe("Streamable HTTP static server token auth", () => {
+    test("refuses startup with PAT and no MCP-layer auth", async () => {
+        const port = await findAvailablePort(4300);
+        const child = startServer({ GITLAB_PERSONAL_ACCESS_TOKEN: "glpat_test" }, port);
+        const { code, output } = await waitForExit(child);
+        assert.notEqual(code, 0);
+        assert.match(output, new RegExp(ERROR_MESSAGE.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")));
+    });
+    test("refuses startup with JOB-TOKEN and no MCP-layer auth", async () => {
+        const port = await findAvailablePort(4310);
+        const child = startServer({ GITLAB_JOB_TOKEN: "job_test" }, port);
+        const { code, output } = await waitForExit(child);
+        assert.notEqual(code, 0);
+        assert.match(output, new RegExp(ERROR_MESSAGE.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")));
+    });
+    test("allows startup with PAT when REMOTE_AUTHORIZATION is enabled", async () => {
+        const port = await findAvailablePort(4320);
+        startServer({
+            GITLAB_PERSONAL_ACCESS_TOKEN: "glpat_test",
+            REMOTE_AUTHORIZATION: "true",
+        }, port);
+        await waitForHealth(port);
+        const initResponse = await postMcpWithoutAuth(port);
+        assert.equal(initResponse.status, 200);
+        const sessionId = initResponse.headers.get("mcp-session-id");
+        assert.ok(sessionId);
+        const followUpResponse = await postMcpWithSessionWithoutAuth(port, sessionId);
+        assert.equal(followUpResponse.status, 401);
+    });
+    test("allows startup with PAT when GITLAB_MCP_OAUTH is enabled", async () => {
+        const port = await findAvailablePort(4330);
+        startServer({
+            GITLAB_PERSONAL_ACCESS_TOKEN: "glpat_test",
+            GITLAB_MCP_OAUTH: "true",
+            MCP_SERVER_URL: `http://${HOST}:${port}`,
+            GITLAB_OAUTH_APP_ID: "oauth-app-id",
+        }, port);
+        await waitForHealth(port);
+        const response = await postMcpWithoutAuth(port);
+        assert.equal(response.status, 401);
+    });
+});

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

@@ -0,0 +1,191 @@
+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(9260);
+        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"));
+    });
+});