@zereight/mcp-gitlab 2.1.70 → 2.2.0

package/build/test/test-health-check.js

@@ -1,115 +0,0 @@
-import { describe, test } from "node:test";
-import assert from "node:assert";
-import { spawn } from "child_process";
-import fs from "node:fs";
-import path, { dirname } from "node:path";
-import { fileURLToPath } from "node:url";
-import { MockGitLabServer, findMockServerPort } from "./utils/mock-gitlab-server.js";
-const MOCK_TOKEN = "glpat-mock-token-12345";
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-const packageJsonPath = path.resolve(__dirname, "../package.json");
-const PACKAGE_VERSION = JSON.parse(fs.readFileSync(packageJsonPath, "utf8")).version;
-function createMockGitLabServer(port) {
-    return new MockGitLabServer({
-        port,
-        validTokens: [MOCK_TOKEN],
-    });
-}
-function baseEnv(mockGitLabUrl) {
-    return {
-        GITLAB_API_URL: `${mockGitLabUrl}/api/v4`,
-        GITLAB_PERSONAL_ACCESS_TOKEN: MOCK_TOKEN,
-        GITLAB_TOOLSETS: "projects",
-    };
-}
-async function callHealthCheckAsync(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", (chunk) => (output += chunk));
-        proc.stderr?.on("data", (chunk) => (errorOutput += chunk));
-        proc.on("close", code => {
-            if (code !== 0) {
-                return reject(new Error(`Process exited with code ${code}: ${errorOutput}`));
-            }
-            const line = output.split("\n").find(entry => entry.startsWith("{"));
-            if (!line) {
-                return reject(new Error("No JSON output found"));
-            }
-            try {
-                const response = JSON.parse(line);
-                if (response.error) {
-                    reject(response.error);
-                    return;
-                }
-                const content = response.result?.content?.[0]?.text;
-                if (!content) {
-                    reject(new Error("No tool result content"));
-                    return;
-                }
-                resolve(JSON.parse(content));
-            }
-            catch (error) {
-                reject(error);
-            }
-        });
-        proc.stdin?.end(JSON.stringify({
-            jsonrpc: "2.0",
-            id: 1,
-            method: "tools/call",
-            params: { name: "health_check", arguments: {} },
-        }) + "\n");
-    });
-}
-describe("When health_check runs", () => {
-    describe("with authenticated mock GitLab", () => {
-        test("should include GitLab instance version metadata", async () => {
-            const mockPort = await findMockServerPort();
-            const mockGitLab = createMockGitLabServer(mockPort);
-            await mockGitLab.start();
-            try {
-                const result = await callHealthCheckAsync(baseEnv(mockGitLab.getUrl()));
-                assert.equal(result.status, "ok");
-                assert.equal(result.authenticated, true);
-                assert.equal(result.mcp_server_version, PACKAGE_VERSION);
-                assert.equal(result.version, "18.3.1-ee");
-                assert.equal(result.revision, "abc1234");
-                assert.equal(result.enterprise, true);
-            }
-            finally {
-                await mockGitLab.stop();
-            }
-        });
-    });
-    describe("when GitLab /version lookup fails", () => {
-        test("should keep health check ok without version fields", async () => {
-            const mockPort = await findMockServerPort();
-            const mockGitLab = createMockGitLabServer(mockPort);
-            mockGitLab.addMockHandler("get", "/version", (_req, res) => {
-                res.status(500).json({ message: "version unavailable" });
-            });
-            await mockGitLab.start();
-            try {
-                const result = await callHealthCheckAsync(baseEnv(mockGitLab.getUrl()));
-                assert.equal(result.status, "ok");
-                assert.equal(result.authenticated, true);
-                assert.equal(result.mcp_server_version, PACKAGE_VERSION);
-                assert.equal("version" in result, false);
-                assert.equal("revision" in result, false);
-                assert.equal("enterprise" in result, false);
-            }
-            finally {
-                await mockGitLab.stop();
-            }
-        });
-    });
-});

package/build/test/test-issue-description-patch.js

@@ -1,256 +0,0 @@
-/**
- * Tests for the update_issue_description_patch tool.
- * Tests search_replace, unified_diff, dry_run, create_note, and edge cases.
- */
-import { describe, test, before, after } from "node:test";
-import assert from "node:assert";
-import { launchServer, cleanupServers, TransportMode, HOST, } from "./utils/server-launcher.js";
-import { MockGitLabServer, findMockServerPort, } from "./utils/mock-gitlab-server.js";
-import { CustomHeaderClient } from "./clients/custom-header-client.js";
-import { parseSearchReplaceBlocks, applySearchReplace, applyUnifiedDiff, } from "../utils/patch-helper.js";
-const MOCK_TOKEN = "glpat-patch-test-token-12345";
-// ---- Unit tests for patch helper ----
-describe("parseSearchReplaceBlocks", () => {
-    test("parses a single block", () => {
-        const blocks = parseSearchReplaceBlocks("<<<<<<< SEARCH\nold text\n=======\nnew text\n>>>>>>> REPLACE");
-        assert.strictEqual(blocks.length, 1);
-        assert.strictEqual(blocks[0].search, "old text");
-        assert.strictEqual(blocks[0].replace, "new text");
-    });
-    test("parses multiple blocks", () => {
-        const blocks = parseSearchReplaceBlocks("<<<<<<< SEARCH\nfirst\n=======\nfirst new\n>>>>>>> REPLACE\n<<<<<<< SEARCH\nsecond\n=======\nsecond new\n>>>>>>> REPLACE");
-        assert.strictEqual(blocks.length, 2);
-    });
-    test("handles empty content", () => {
-        const blocks = parseSearchReplaceBlocks("");
-        assert.strictEqual(blocks.length, 0);
-    });
-    test("ignores text outside blocks", () => {
-        const blocks = parseSearchReplaceBlocks("prefix\n<<<<<<< SEARCH\nx\n=======\ny\n>>>>>>> REPLACE\nsuffix");
-        assert.strictEqual(blocks.length, 1);
-    });
-    test("rejects malformed block with missing REPLACE marker", () => {
-        assert.throws(() => parseSearchReplaceBlocks("<<<<<<< SEARCH\nfirst\n=======\nfirst new\n>>>>>>> REPLACE\n" +
-            "<<<<<<< SEARCH\nsecond\n=======\nsecond new\n>>>>>>> TYPO"), /malformed|Marker|marker/);
-    });
-    test("rejects block with missing ======= marker", () => {
-        assert.throws(() => parseSearchReplaceBlocks("<<<<<<< SEARCH\nfoo\n\nbar\n>>>>>>> REPLACE"), /malformed|Marker|marker/);
-    });
-    test("allows prose around valid blocks", () => {
-        const blocks = parseSearchReplaceBlocks("# Some notes\n\n<<<<<<< SEARCH\nfoo\n=======\nbar\n>>>>>>> REPLACE\n\nMore context");
-        assert.strictEqual(blocks.length, 1);
-    });
-});
-describe("applySearchReplace", () => {
-    test("replaces single occurrence", () => {
-        const result = applySearchReplace("Status: In progress\nDone.", [
-            { search: "Status: In progress", replace: "Status: Done" },
-        ]);
-        assert.strictEqual(result.description, "Status: Done\nDone.");
-        assert.strictEqual(result.changes, 1);
-        assert.ok(result.summary.includes("Status: In progress"));
-        assert.ok(result.preview.includes("-Status: In progress"));
-    });
-    test("fails on no match", () => {
-        assert.throws(() => applySearchReplace("Some text.", [{ search: "Nonexistent", replace: "x" }]), /Search text not found/);
-    });
-    test("rejects empty SEARCH body", () => {
-        assert.throws(() => applySearchReplace("Some text.", [{ search: "", replace: "x" }], true), /Empty SEARCH/);
-    });
-    test("fails on duplicate without allowMultiple", () => {
-        assert.throws(() => applySearchReplace("x\ny\nx\n", [{ search: "x", replace: "z" }]), /matches 2 times/);
-    });
-    test("replaces all with allowMultiple", () => {
-        const result = applySearchReplace("x\ny\nx\n", [{ search: "x", replace: "z" }], true);
-        assert.strictEqual(result.changes, 2);
-        assert.strictEqual(result.description, "z\ny\nz\n");
-    });
-    test("fails on identical replacement", () => {
-        assert.throws(() => applySearchReplace("Keep this.", [{ search: "Keep this.", replace: "Keep this." }]), /did not change/);
-    });
-    test("preserves leading blank line in SEARCH block", () => {
-        const source = "\n\nStatus: In progress\n";
-        const result = applySearchReplace(source, [
-            { search: "\n\nStatus: In progress", replace: "\n\nStatus: Done" },
-        ]);
-        assert.strictEqual(result.description, "\n\nStatus: Done\n");
-    });
-    test("preserves leading blank line when patch starts with blank line", () => {
-        const blocks = parseSearchReplaceBlocks("<<<<<<< SEARCH\n\nfoo\n=======\n\nbar\n>>>>>>> REPLACE");
-        assert.strictEqual(blocks.length, 1);
-        assert.strictEqual(blocks[0].search, "\nfoo");
-        assert.strictEqual(blocks[0].replace, "\nbar");
-    });
-    test("replacement with leading blank line works", () => {
-        const result = applySearchReplace("Header\n\nContent\n", [
-            { search: "Content", replace: "\nNewContent" },
-        ]);
-        assert.strictEqual(result.description, "Header\n\n\nNewContent\n");
-    });
-});
-describe("applyUnifiedDiff", () => {
-    test("applies simple diff", () => {
-        const source = "Line 1\nLine 2\nLine 3\n";
-        const patch = "--- old\n+++ new\n@@ -1,3 +1,3 @@\n Line 1\n-Line 2\n+Line 2 modified\n Line 3\n";
-        const result = applyUnifiedDiff(source, patch);
-        assert.ok(result.description.includes("Line 2 modified"));
-    });
-    test("fails on non-matching diff", () => {
-        const source = "AAA\nBBB\n";
-        const patch = "--- old\n+++ new\n@@ -1,2 +1,2 @@\n-XXX\n+YYY\n BBB\n";
-        assert.throws(() => applyUnifiedDiff(source, patch), /could not be applied/);
-    });
-    test("fails on malformed patch", () => {
-        assert.throws(() => applyUnifiedDiff("text", "not a patch"), /no valid hunks/i);
-    });
-});
-// ---- Integration tests via MCP client ----
-describe("update_issue_description_patch MCP tool", () => {
-    let mockGitLab;
-    let server;
-    let client;
-    const MOCK_PORT_BASE = 9600;
-    const MCP_PORT_BASE = 3600;
-    let portCounter = 0;
-    async function launchMcp(mockGitLabUrl, extraEnv = {}) {
-        const port = MCP_PORT_BASE + portCounter++ * 10;
-        return launchServer({
-            mode: TransportMode.STREAMABLE_HTTP,
-            port,
-            timeout: 10000,
-            env: {
-                STREAMABLE_HTTP: "true",
-                REMOTE_AUTHORIZATION: "true",
-                GITLAB_API_URL: `${mockGitLabUrl}/api/v4`,
-                GITLAB_ACCESS_TOKEN: MOCK_TOKEN,
-                ...extraEnv,
-            },
-        });
-    }
-    async function getClient(port) {
-        const client = new CustomHeaderClient({
-            headers: {
-                authorization: `Bearer ${MOCK_TOKEN}`,
-            },
-        });
-        await client.connect(`http://${HOST}:${port}/mcp`);
-        return client;
-    }
-    before(async () => {
-        const mockPort = await findMockServerPort();
-        mockGitLab = new MockGitLabServer({
-            port: mockPort,
-            validTokens: [MOCK_TOKEN],
-        });
-        await mockGitLab.start();
-        const mockGitLabUrl = mockGitLab.getUrl();
-        server = await launchMcp(mockGitLabUrl, { GITLAB_TOOLSETS: "issues" });
-        client = await getClient(server.port ?? 0);
-    });
-    after(async () => {
-        await client?.disconnect();
-        cleanupServers([server]);
-        await mockGitLab?.stop();
-    });
-    test("tool appears in tool list", async () => {
-        const result = await client.listTools();
-        const names = result.tools.map((t) => t.name);
-        assert.ok(names.includes("update_issue_description_patch"), "tool should be in list");
-    });
-    test("dry_run: search_replace returns preview without modifying", async () => {
-        // Get current description
-        const getResult = await client.callTool("get_issue", {
-            project_id: "test/project",
-            issue_iid: "1",
-        });
-        const issue = JSON.parse(getResult.content[0]?.text || "{}");
-        const originalDesc = issue.description;
-        // Dry-run
-        const result = await client.callTool("update_issue_description_patch", {
-            project_id: "test/project",
-            issue_iid: "1",
-            patch_type: "search_replace",
-            patch: `<<<<<<< SEARCH\n${originalDesc}\n=======\nShould NOT persist\n>>>>>>> REPLACE`,
-            dry_run: true,
-        });
-        const data = JSON.parse(result.content[0]?.text || "{}");
-        assert.strictEqual(data.status, "preview");
-        assert.strictEqual(data.dry_run, true);
-        assert.strictEqual(data.changes, 1);
-        // Verify NOT updated
-        const getAgain = await client.callTool("get_issue", {
-            project_id: "test/project",
-            issue_iid: "1",
-        });
-        const issueAgain = JSON.parse(getAgain.content[0]?.text || "{}");
-        assert.strictEqual(issueAgain.description, originalDesc, "should be unchanged after dry_run");
-    });
-    test("search_replace: applies the patch", async () => {
-        const result = await client.callTool("update_issue_description_patch", {
-            project_id: "test/project",
-            issue_iid: "1",
-            patch_type: "search_replace",
-            patch: `<<<<<<< SEARCH\nDescription for issue 1\n=======\nPatched description\n>>>>>>> REPLACE`,
-        });
-        const data = JSON.parse(result.content[0]?.text || "{}");
-        assert.strictEqual(data.status, "success");
-        assert.strictEqual(data.changes, 1);
-        // Verify persisted
-        const getResult = await client.callTool("get_issue", {
-            project_id: "test/project",
-            issue_iid: "1",
-        });
-        const issue = JSON.parse(getResult.content[0]?.text || "{}");
-        assert.strictEqual(issue.description, "Patched description");
-    });
-    test("create_note: note is attempted after update", async () => {
-        const result = await client.callTool("update_issue_description_patch", {
-            project_id: "test/project",
-            issue_iid: "1",
-            patch_type: "search_replace",
-            patch: `<<<<<<< SEARCH\nPatched description\n=======\nDescription with note\n>>>>>>> REPLACE`,
-            create_note: true,
-        });
-        const data = JSON.parse(result.content[0]?.text || "{}");
-        assert.strictEqual(data.status, "success");
-        assert.ok(data.note !== undefined, "note result should be present");
-    });
-    test("search_replace: fails on no match", async () => {
-        try {
-            await client.callTool("update_issue_description_patch", {
-                project_id: "test/project",
-                issue_iid: "1",
-                patch_type: "search_replace",
-                patch: `<<<<<<< SEARCH\nNonExistentText_{UNIQUE}_\n=======\nShould fail\n>>>>>>> REPLACE`,
-            });
-            assert.fail("Should have thrown");
-        }
-        catch (err) {
-            const msg = err.message ?? String(err);
-            assert.ok(msg.includes("not found"), `Error should mention 'not found': ${msg}`);
-        }
-    });
-    test("unified_diff: applies the patch", async () => {
-        // Set known state
-        await client.callTool("update_issue_description_patch", {
-            project_id: "test/project",
-            issue_iid: "1",
-            patch_type: "search_replace",
-            patch: `<<<<<<< SEARCH\nDescription with note\n=======\nLine 1\nLine 2\nLine 3\n>>>>>>> REPLACE`,
-        });
-        const result = await client.callTool("update_issue_description_patch", {
-            project_id: "test/project",
-            issue_iid: "1",
-            patch_type: "unified_diff",
-            patch: "--- old\n+++ new\n@@ -1,3 +1,3 @@\n Line 1\n-Line 2\n+Line 2 changed\n Line 3\n",
-        });
-        const data = JSON.parse(result.content[0]?.text || "{}");
-        assert.strictEqual(data.status, "success");
-        const getResult = await client.callTool("get_issue", {
-            project_id: "test/project",
-            issue_iid: "1",
-        });
-        const issue = JSON.parse(getResult.content[0]?.text || "{}");
-        assert.ok(issue.description.includes("Line 2 changed"));
-    });
-});

package/build/test/test-job-artifacts.js

@@ -1,275 +0,0 @@
-import { describe, test, it, before, after } from 'node:test';
-import assert from 'node:assert';
-import { spawn } from 'child_process';
-import { MockGitLabServer, findMockServerPort } from './utils/mock-gitlab-server.js';
-import fs from 'node:fs';
-import path from 'node:path';
-import os from 'node:os';
-const MOCK_TOKEN = 'glpat-mock-token-12345';
-const TEST_PROJECT_ID = '123';
-const TEST_JOB_ID = '456';
-const NULL_MODE_JOB_ID = '457';
-const REDIRECT_JOB_ID = '789';
-const REDIRECT_TARGET = 'http://169.254.169.254/latest/meta-data/';
-const TEST_ENCODED_ARTIFACT_PATH = 'reports/report#1.txt';
-// Helper to run an MCP tool via the built 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,
-                ...env,
-                GITLAB_READ_ONLY_MODE: 'true',
-                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;
-                    if (content) {
-                        try {
-                            resolve(JSON.parse(content));
-                        }
-                        catch {
-                            // Not JSON (plain text response)
-                            resolve(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('job artifacts tools', () => {
-    let mockGitLab;
-    let mockGitLabUrl;
-    let tmpDir;
-    before(async () => {
-        const mockPort = await findMockServerPort();
-        mockGitLab = new MockGitLabServer({
-            port: mockPort,
-            validTokens: [MOCK_TOKEN],
-        });
-        // Add mock handler for artifact tree listing
-        mockGitLab.addMockHandler('get', `/projects/${TEST_PROJECT_ID}/jobs/${TEST_JOB_ID}/artifacts/tree`, (req, res) => {
-            res.json([
-                {
-                    name: 'report.xml',
-                    path: 'report.xml',
-                    type: 'file',
-                    size: 1024,
-                    mode: '100644',
-                },
-                {
-                    name: 'logs',
-                    path: 'logs',
-                    type: 'directory',
-                    mode: '040755',
-                },
-                {
-                    name: 'output.log',
-                    path: 'logs/output.log',
-                    type: 'file',
-                    size: 512,
-                    mode: '100644',
-                },
-            ]);
-        });
-        // Add mock handler for downloading the full artifact archive
-        mockGitLab.addMockHandler('get', `/projects/${TEST_PROJECT_ID}/jobs/${TEST_JOB_ID}/artifacts`, (req, res) => {
-            // Return a minimal zip-like binary content for testing
-            const fakeZipContent = Buffer.from('PK\x03\x04fake-zip-content-for-testing');
-            res.set('Content-Type', 'application/zip');
-            res.set('Content-Disposition', `attachment; filename="artifacts_job_${TEST_JOB_ID}.zip"`);
-            res.send(fakeZipContent);
-        });
-        // Add mock handler for getting a single artifact file
-        mockGitLab.addMockHandler('get', `/projects/${TEST_PROJECT_ID}/jobs/${TEST_JOB_ID}/artifacts/report.xml`, (req, res) => {
-            res.set('Content-Type', 'application/xml');
-            res.send('<testsuites><testsuite name="unit" tests="5" failures="1"></testsuite></testsuites>');
-        });
-        // Add mock handler for path that requires URL encoding
-        mockGitLab.addMockHandler('get', `/projects/${TEST_PROJECT_ID}/jobs/${TEST_JOB_ID}/artifacts/reports/report%231.txt`, (req, res) => {
-            res.set('Content-Type', 'text/plain');
-            res.send('encoded artifact content');
-        });
-        // GitLab.com can return mode/size as null on artifacts/tree entries (#661)
-        mockGitLab.addMockHandler('get', `/projects/${TEST_PROJECT_ID}/jobs/${NULL_MODE_JOB_ID}/artifacts/tree`, (req, res) => {
-            res.json([
-                {
-                    name: 'report.xml',
-                    path: 'report.xml',
-                    type: 'file',
-                    size: 1024,
-                    mode: null,
-                },
-                {
-                    name: 'logs',
-                    path: 'logs',
-                    type: 'directory',
-                    size: null,
-                    mode: '040755',
-                },
-            ]);
-        });
-        // Add mock handler for 404 on non-existent artifact
-        mockGitLab.addMockHandler('get', `/projects/${TEST_PROJECT_ID}/jobs/999/artifacts/tree`, (req, res) => {
-            res.status(404).json({ message: 'Not Found' });
-        });
-        // GitLab redirects artifact downloads to its object storage, so the hop after this
-        // response leaves the origin. The destination is a non-public address here.
-        mockGitLab.addMockHandler('get', `/projects/${TEST_PROJECT_ID}/jobs/${REDIRECT_JOB_ID}/artifacts`, (req, res) => {
-            res.redirect(REDIRECT_TARGET);
-        });
-        mockGitLab.addMockHandler('get', `/projects/${TEST_PROJECT_ID}/jobs/${REDIRECT_JOB_ID}/artifacts/report.xml`, (req, res) => {
-            res.redirect(REDIRECT_TARGET);
-        });
-        await mockGitLab.start();
-        mockGitLabUrl = mockGitLab.getUrl();
-        // Relative temp dir — absolute local_path is rejected as traversal
-        tmpDir = `gitlab-mcp-test-artifacts-${process.pid}`;
-        fs.mkdirSync(tmpDir, { recursive: true });
-    });
-    after(async () => {
-        await mockGitLab.stop();
-        // Clean up temp directory
-        if (tmpDir && fs.existsSync(tmpDir)) {
-            fs.rmSync(tmpDir, { recursive: true, force: true });
-        }
-    });
-    test('list_job_artifacts returns artifact entries', async () => {
-        const result = await callTool('list_job_artifacts', { project_id: TEST_PROJECT_ID, job_id: TEST_JOB_ID }, {
-            GITLAB_API_URL: `${mockGitLabUrl}/api/v4`,
-            GITLAB_PERSONAL_ACCESS_TOKEN: MOCK_TOKEN,
-        });
-        assert.ok(Array.isArray(result), 'Response should be an array');
-        assert.strictEqual(result.length, 3, 'Should return 3 artifact entries');
-        assert.strictEqual(result[0].name, 'report.xml');
-        assert.strictEqual(result[0].type, 'file');
-        assert.strictEqual(result[0].size, 1024);
-        assert.strictEqual(result[1].name, 'logs');
-        assert.strictEqual(result[1].type, 'directory');
-    });
-    describe('When listing job artifacts', () => {
-        describe('with a null mode entry', () => {
-            it('should return the entries instead of failing', async () => {
-                const result = await callTool('list_job_artifacts', { project_id: TEST_PROJECT_ID, job_id: NULL_MODE_JOB_ID }, {
-                    GITLAB_API_URL: `${mockGitLabUrl}/api/v4`,
-                    GITLAB_PERSONAL_ACCESS_TOKEN: MOCK_TOKEN,
-                });
-                assert.ok(Array.isArray(result), 'Response should be an array');
-                assert.strictEqual(result.length, 2);
-                assert.strictEqual(result[0].mode, null);
-                assert.strictEqual(result[1].size, null);
-            });
-        });
-    });
-    test('download_job_artifacts saves archive to disk', async () => {
-        const result = await callTool('download_job_artifacts', { project_id: TEST_PROJECT_ID, job_id: TEST_JOB_ID, local_path: tmpDir }, {
-            GITLAB_API_URL: `${mockGitLabUrl}/api/v4`,
-            GITLAB_PERSONAL_ACCESS_TOKEN: MOCK_TOKEN,
-        });
-        assert.ok(result.success, 'Download should succeed');
-        assert.ok(result.file_path.endsWith('.zip'), 'File should have .zip extension');
-        assert.ok(fs.existsSync(result.file_path), `File should exist at ${result.file_path}`);
-        const stats = fs.statSync(result.file_path);
-        assert.ok(stats.size > 0, 'Downloaded file should not be empty');
-    });
-    test('download_job_artifacts creates nested destination directories', async () => {
-        const nestedLocalPath = path.join(tmpDir, 'artifacts', 'run-42');
-        const result = await callTool('download_job_artifacts', { project_id: TEST_PROJECT_ID, job_id: TEST_JOB_ID, local_path: nestedLocalPath }, {
-            GITLAB_API_URL: `${mockGitLabUrl}/api/v4`,
-            GITLAB_PERSONAL_ACCESS_TOKEN: MOCK_TOKEN,
-        });
-        assert.ok(result.success, 'Download should succeed');
-        assert.ok(fs.existsSync(result.file_path), `File should exist at ${result.file_path}`);
-        assert.ok(fs.existsSync(nestedLocalPath), `Directory should be created at ${nestedLocalPath}`);
-    });
-    test('download_job_artifacts rejects local_path with directory traversal', async () => {
-        await assert.rejects(() => callTool('download_job_artifacts', { project_id: TEST_PROJECT_ID, job_id: TEST_JOB_ID, local_path: '../../../tmp' }, {
-            GITLAB_API_URL: `${mockGitLabUrl}/api/v4`,
-            GITLAB_PERSONAL_ACCESS_TOKEN: MOCK_TOKEN,
-        }), (err) => {
-            const msg = String(err.message || err).toLowerCase();
-            return msg.includes('traversal') || msg.includes('invalid');
-        });
-    });
-    test('download_job_artifacts rejects symlink local_path escape', async () => {
-        const linkName = path.join(tmpDir, 'symlink-escape');
-        fs.symlinkSync(os.tmpdir(), linkName);
-        await assert.rejects(() => callTool('download_job_artifacts', { project_id: TEST_PROJECT_ID, job_id: TEST_JOB_ID, local_path: linkName }, {
-            GITLAB_API_URL: `${mockGitLabUrl}/api/v4`,
-            GITLAB_PERSONAL_ACCESS_TOKEN: MOCK_TOKEN,
-        }), (err) => {
-            const msg = String(err.message || err).toLowerCase();
-            return (msg.includes('symbolic') ||
-                msg.includes('symlink') ||
-                msg.includes('escapes') ||
-                msg.includes('traversal') ||
-                msg.includes('invalid'));
-        });
-    });
-    test('get_job_artifact_file returns file content', async () => {
-        const result = await callTool('get_job_artifact_file', {
-            project_id: TEST_PROJECT_ID,
-            job_id: TEST_JOB_ID,
-            artifact_path: 'report.xml',
-        }, {
-            GITLAB_API_URL: `${mockGitLabUrl}/api/v4`,
-            GITLAB_PERSONAL_ACCESS_TOKEN: MOCK_TOKEN,
-        });
-        assert.ok(typeof result === 'string', 'Response should be a string');
-        assert.ok(result.includes('<testsuites>'), 'Should contain XML content');
-        assert.ok(result.includes('failures="1"'), 'Should contain failure data');
-    });
-    test('get_job_artifact_file handles artifact paths with reserved characters', async () => {
-        const result = await callTool('get_job_artifact_file', {
-            project_id: TEST_PROJECT_ID,
-            job_id: TEST_JOB_ID,
-            artifact_path: TEST_ENCODED_ARTIFACT_PATH,
-        }, {
-            GITLAB_API_URL: `${mockGitLabUrl}/api/v4`,
-            GITLAB_PERSONAL_ACCESS_TOKEN: MOCK_TOKEN,
-        });
-        assert.strictEqual(result, 'encoded artifact content');
-    });
-    test('download_job_artifacts refuses a redirect to a non-public address', async () => {
-        await assert.rejects(() => callTool('download_job_artifacts', { project_id: TEST_PROJECT_ID, job_id: REDIRECT_JOB_ID, local_path: tmpDir }, {
-            GITLAB_API_URL: `${mockGitLabUrl}/api/v4`,
-            GITLAB_PERSONAL_ACCESS_TOKEN: MOCK_TOKEN,
-        }), (err) => String(err.message || err).toLowerCase().includes('non-public address'));
-    });
-    test('get_job_artifact_file refuses a redirect to a non-public address', async () => {
-        await assert.rejects(() => callTool('get_job_artifact_file', { project_id: TEST_PROJECT_ID, job_id: REDIRECT_JOB_ID, artifact_path: 'report.xml' }, {
-            GITLAB_API_URL: `${mockGitLabUrl}/api/v4`,
-            GITLAB_PERSONAL_ACCESS_TOKEN: MOCK_TOKEN,
-        }), (err) => String(err.message || err).toLowerCase().includes('non-public address'));
-    });
-});