@zereight/mcp-gitlab 2.1.70 → 2.2.1

package/build/test/dynamic-routing-tests.js

@@ -1,495 +0,0 @@
-import { describe, test, after, before } from 'node:test';
-import assert from 'node:assert';
-import { launchServer, findAvailablePort, TransportMode, HOST } from './utils/server-launcher.js';
-import { MockGitLabServer, findMockServerPort } from './utils/mock-gitlab-server.js';
-import { CustomHeaderClient } from './clients/custom-header-client.js';
-const MOCK_TOKEN_DEFAULT = 'glpat-mock-token-default';
-const MOCK_TOKEN_HEADER = 'glpat-mock-token-header';
-describe('Dynamic Routing and Authentication Scenarios', () => {
-    const originalToken = process.env.GITLAB_TOKEN_TEST;
-    before(() => {
-        process.env.GITLAB_TOKEN_TEST = 'mock-token-for-launcher';
-    });
-    after(() => {
-        if (originalToken) {
-            process.env.GITLAB_TOKEN_TEST = originalToken;
-        }
-        else {
-            delete process.env.GITLAB_TOKEN_TEST;
-        }
-    });
-    // Scenario 1: remote=off, dynamic=off
-    describe('Scenario 1: Remote Auth OFF, Dynamic URL OFF', () => {
-        let mcpServer;
-        let mcpUrl;
-        let mockServer;
-        const originalProjectId = process.env.TEST_PROJECT_ID;
-        before(async () => {
-            // Ensure GITLAB_TOKEN_TEST matches what we expect for this scenario
-            // to avoid launchServer overwriting GITLAB_PERSONAL_ACCESS_TOKEN with a different value
-            process.env.GITLAB_TOKEN_TEST = MOCK_TOKEN_DEFAULT;
-            process.env.TEST_PROJECT_ID = '1';
-            const mockPort = await findMockServerPort();
-            mockServer = new MockGitLabServer({ port: mockPort, validTokens: [MOCK_TOKEN_DEFAULT] });
-            await mockServer.start();
-            const mcpPort = await findAvailablePort(3021);
-            mcpServer = await launchServer({
-                mode: TransportMode.STREAMABLE_HTTP,
-                port: mcpPort,
-                env: {
-                    GITLAB_API_URL: `${mockServer.getUrl()}/api/v4`,
-                    GITLAB_PERSONAL_ACCESS_TOKEN: MOCK_TOKEN_DEFAULT,
-                    REMOTE_AUTHORIZATION: "false",
-                    ENABLE_DYNAMIC_API_URL: "false",
-                    GITLAB_TOKEN_TEST: MOCK_TOKEN_DEFAULT,
-                },
-            });
-            mcpUrl = `http://${HOST}:${mcpPort}/mcp`;
-        });
-        after(async () => {
-            if (originalProjectId) {
-                process.env.TEST_PROJECT_ID = originalProjectId;
-            }
-            else {
-                delete process.env.TEST_PROJECT_ID;
-            }
-            if (mcpServer)
-                mcpServer.kill();
-            if (mockServer)
-                await mockServer.stop();
-        });
-        test('should ignore headers and use startup config', async () => {
-            mockServer.addMockHandler('get', '/projects/1', (req, res) => {
-                // index.ts uses Authorization header by default unless GITLAB_IS_OLD is set
-                assert.strictEqual(req.headers['authorization'], `Bearer ${MOCK_TOKEN_DEFAULT}`);
-                res.json({ id: 1, default_branch: 'main' });
-            });
-            const client = new CustomHeaderClient({
-                headers: {
-                    'authorization': `Bearer ${MOCK_TOKEN_HEADER}`, // This should be ignored
-                    'X-GitLab-API-URL': 'http://localhost:9999/api/v4', // This should be ignored
-                }
-            });
-            await client.connect(mcpUrl);
-            const result = await client.callTool('get_project', { project_id: "1" });
-            assert.ok(result, 'Should get a result from the tool call');
-            await client.disconnect();
-        });
-    });
-    // Scenario 2: remote=on, dynamic=off
-    describe('Scenario 2: Remote Auth ON, Dynamic URL OFF', () => {
-        let mcpServer;
-        let mcpUrl;
-        let mockServer;
-        before(async () => {
-            const mockPort = await findMockServerPort();
-            mockServer = new MockGitLabServer({ port: mockPort, validTokens: [MOCK_TOKEN_HEADER] });
-            await mockServer.start();
-            const mcpPort = await findAvailablePort(3022);
-            mcpServer = await launchServer({
-                mode: TransportMode.STREAMABLE_HTTP,
-                port: mcpPort,
-                env: {
-                    GITLAB_API_URL: `${mockServer.getUrl()}/api/v4`,
-                    REMOTE_AUTHORIZATION: "true",
-                    ENABLE_DYNAMIC_API_URL: "false",
-                },
-            });
-            mcpUrl = `http://${HOST}:${mcpPort}/mcp`;
-        });
-        after(async () => {
-            if (mcpServer)
-                mcpServer.kill();
-            if (mockServer)
-                await mockServer.stop();
-        });
-        test('should use token from header and ignore dynamic URL', async () => {
-            mockServer.addMockHandler('get', '/projects/1', (req, res) => {
-                assert.strictEqual(req.headers['authorization'], `Bearer ${MOCK_TOKEN_HEADER}`);
-                res.json({ id: 1, default_branch: 'main' });
-            });
-            const client = new CustomHeaderClient({
-                headers: {
-                    'authorization': `Bearer ${MOCK_TOKEN_HEADER}`,
-                    'X-GitLab-API-URL': 'http://localhost:9999/api/v4', // This should be ignored
-                }
-            });
-            await client.connect(mcpUrl);
-            const result = await client.callTool('get_project', { project_id: "1" });
-            assert.ok(result, 'Should get a result from the tool call');
-            await client.disconnect();
-        });
-    });
-    // Scenario 3: remote=off, dynamic=on - should be an error
-    describe('Scenario 3: Remote Auth OFF, Dynamic URL ON (Error Case)', () => {
-        test('should fail to start with an error', async () => {
-            await assert.rejects(launchServer({
-                mode: TransportMode.STREAMABLE_HTTP,
-                port: await findAvailablePort(3023),
-                env: {
-                    REMOTE_AUTHORIZATION: "false",
-                    ENABLE_DYNAMIC_API_URL: "true",
-                    GITLAB_TOKEN_TEST: "mock-token", // Required to bypass launcher check
-                },
-            }), (err) => {
-                // The server process exits with code 1, which launchServer catches and throws as a generic error
-                // We can't easily see the stderr output here without modifying launchServer,
-                // so we accept the exit code 1 error as success for this negative test.
-                return err.message.includes('Server process exited with code 1');
-            });
-        });
-    });
-    // Scenario 4: remote=on, dynamic=on
-    describe('Scenario 4: Remote Auth ON, Dynamic URL ON', () => {
-        let mcpServer;
-        let mcpUrl;
-        let defaultMockServer;
-        let headerMockServer;
-        before(async () => {
-            const defaultPort = await findMockServerPort();
-            defaultMockServer = new MockGitLabServer({ port: defaultPort, validTokens: [MOCK_TOKEN_DEFAULT, MOCK_TOKEN_HEADER] });
-            await defaultMockServer.start();
-            const headerPort = await findMockServerPort();
-            headerMockServer = new MockGitLabServer({ port: headerPort, validTokens: [MOCK_TOKEN_DEFAULT, MOCK_TOKEN_HEADER] });
-            await headerMockServer.start();
-            const mcpPort = await findAvailablePort(3024);
-            mcpServer = await launchServer({
-                mode: TransportMode.STREAMABLE_HTTP,
-                port: mcpPort,
-                env: {
-                    GITLAB_API_URL: `${defaultMockServer.getUrl()}/api/v4`,
-                    GITLAB_PERSONAL_ACCESS_TOKEN: MOCK_TOKEN_DEFAULT,
-                    REMOTE_AUTHORIZATION: "true",
-                    ENABLE_DYNAMIC_API_URL: "true",
-                },
-            });
-            mcpUrl = `http://${HOST}:${mcpPort}/mcp`;
-        });
-        after(async () => {
-            if (mcpServer)
-                mcpServer.kill();
-            if (defaultMockServer)
-                await defaultMockServer.stop();
-            if (headerMockServer)
-                await headerMockServer.stop();
-        });
-        test('should use default URL and token when no headers are provided', async () => {
-            defaultMockServer.addMockHandler('get', '/projects/1', (req, res) => {
-                assert.strictEqual(req.headers['private-token'], MOCK_TOKEN_DEFAULT);
-                res.json(createMockProject(1, 'default-server'));
-            });
-            const client = new CustomHeaderClient({ headers: { 'private-token': MOCK_TOKEN_DEFAULT } });
-            await client.connect(mcpUrl);
-            const result = await client.callTool('get_project', { project_id: "1" });
-            const resultContent = JSON.parse(result.content[0].text);
-            assert.strictEqual(resultContent.description, 'default-server');
-            await client.disconnect();
-        });
-        test('should use custom URL from header and default token', async () => {
-            headerMockServer.addMockHandler('get', '/projects/2', (req, res) => {
-                assert.strictEqual(req.headers['private-token'], MOCK_TOKEN_DEFAULT);
-                res.json(createMockProject(2, 'header-server'));
-            });
-            const client = new CustomHeaderClient({
-                headers: {
-                    'private-token': MOCK_TOKEN_DEFAULT,
-                    'X-GitLab-API-URL': `${headerMockServer.getUrl()}/api/v4`,
-                }
-            });
-            await client.connect(mcpUrl);
-            const result = await client.callTool('get_project', { project_id: "2" });
-            const resultContent = JSON.parse(result.content[0].text);
-            assert.strictEqual(resultContent.description, 'header-server');
-            await client.disconnect();
-        });
-        test('should use custom URL and token from headers', async () => {
-            headerMockServer.addMockHandler('get', '/projects/3', (req, res) => {
-                assert.strictEqual(req.headers['authorization'], `Bearer ${MOCK_TOKEN_HEADER}`);
-                res.json(createMockProject(3, 'header-server-with-header-token'));
-            });
-            const client = new CustomHeaderClient({
-                headers: {
-                    'authorization': `Bearer ${MOCK_TOKEN_HEADER}`,
-                    'X-GitLab-API-URL': `${headerMockServer.getUrl()}/api/v4`,
-                }
-            });
-            await client.connect(mcpUrl);
-            const result = await client.callTool('get_project', { project_id: "3" });
-            const resultContent = JSON.parse(result.content[0].text);
-            assert.strictEqual(resultContent.description, 'header-server-with-header-token');
-            await client.disconnect();
-        });
-        test('should work with multiple tool calls', async () => {
-            const client = new CustomHeaderClient({
-                headers: {
-                    'authorization': `Bearer ${MOCK_TOKEN_HEADER}`,
-                    'X-GitLab-API-URL': `${headerMockServer.getUrl()}/api/v4`,
-                }
-            });
-            await client.connect(mcpUrl);
-            await validateToolCalls(client, headerMockServer, MOCK_TOKEN_HEADER);
-            await client.disconnect();
-        });
-        test('should preserve legacy tree array response and return keyset metadata when requested', async () => {
-            const client = new CustomHeaderClient({
-                headers: {
-                    'authorization': `Bearer ${MOCK_TOKEN_HEADER}`,
-                    'X-GitLab-API-URL': `${headerMockServer.getUrl()}/api/v4`,
-                }
-            });
-            await client.connect(mcpUrl);
-            headerMockServer.clearCustomHandlers();
-            headerMockServer.addMockHandler('get', '/projects/4/repository/tree', (req, res) => {
-                assert.strictEqual(req.headers['authorization'], `Bearer ${MOCK_TOKEN_HEADER}`);
-                assert.strictEqual(req.query.pagination, undefined);
-                res.json([createMockTreeItem('legacy-blob')]);
-            });
-            const legacyResult = await client.callTool('get_repository_tree', { project_id: '4' });
-            const legacyContent = JSON.parse(legacyResult.content[0].text);
-            assert.ok(Array.isArray(legacyContent));
-            assert.strictEqual(legacyContent[0].id, 'legacy-blob');
-            headerMockServer.clearCustomHandlers();
-            headerMockServer.addMockHandler('get', '/projects/4/repository/tree', (req, res) => {
-                assert.strictEqual(req.headers['authorization'], `Bearer ${MOCK_TOKEN_HEADER}`);
-                assert.strictEqual(req.query.pagination, 'keyset');
-                res.set('x-next-page-token', 'token-blob');
-                res.json([createMockTreeItem('keyset-blob')]);
-            });
-            const keysetResult = await client.callTool('get_repository_tree', {
-                project_id: '4',
-                pagination: 'keyset',
-            });
-            const keysetContent = JSON.parse(keysetResult.content[0].text);
-            assert.ok(!Array.isArray(keysetContent));
-            assert.strictEqual(keysetContent.items[0].id, 'keyset-blob');
-            assert.strictEqual(keysetContent.next_page_token, 'token-blob');
-            headerMockServer.clearCustomHandlers();
-            headerMockServer.addMockHandler('get', '/projects/4/repository/tree', (req, res) => {
-                assert.strictEqual(req.headers['authorization'], `Bearer ${MOCK_TOKEN_HEADER}`);
-                assert.strictEqual(req.query.pagination, 'keyset');
-                res.set('x-next-page', 'fallback-token');
-                res.json([createMockTreeItem('fallback-blob')]);
-            });
-            const fallbackResult = await client.callTool('get_repository_tree', {
-                project_id: '4',
-                pagination: 'keyset',
-            });
-            const fallbackContent = JSON.parse(fallbackResult.content[0].text);
-            assert.strictEqual(fallbackContent.items[0].id, 'fallback-blob');
-            assert.strictEqual(fallbackContent.next_page_token, 'fallback-token');
-            await client.disconnect();
-        });
-    });
-});
-// Helper functions to create schema-compliant mock objects
-function createMockUser() {
-    return {
-        id: 1,
-        username: 'mock_user',
-        name: 'Mock User',
-        state: 'active',
-        avatar_url: 'https://example.com/avatar.png',
-        web_url: 'https://example.com/mock_user'
-    };
-}
-function createMockProject(id, description = 'Mock Project') {
-    return {
-        id,
-        name: `Project ${id}`,
-        path_with_namespace: `group/project-${id}`,
-        description,
-        visibility: 'private',
-        web_url: `https://gitlab.example.com/group/project-${id}`,
-        created_at: '2024-01-01T00:00:00Z',
-        last_activity_at: '2024-01-01T00:00:00Z',
-        default_branch: 'main',
-        namespace: {
-            id: 1,
-            name: 'Group',
-            path: 'group',
-            kind: 'group',
-            full_path: 'group',
-            web_url: 'https://gitlab.example.com/group'
-        }
-    };
-}
-function createMockIssue(id, projectId) {
-    return {
-        id,
-        iid: id,
-        project_id: projectId,
-        title: `Issue ${id}`,
-        description: 'Description',
-        state: 'opened',
-        created_at: '2024-01-01T00:00:00Z',
-        updated_at: '2024-01-01T00:00:00Z',
-        closed_at: null,
-        web_url: `https://gitlab.example.com/group/project-${projectId}/issues/${id}`,
-        author: createMockUser(),
-        assignees: [],
-        labels: [],
-        milestone: null,
-        user_notes_count: 0,
-        upvotes: 0,
-        downvotes: 0,
-        confidential: false
-    };
-}
-function createMockMergeRequest(id, projectId) {
-    return {
-        id,
-        iid: id,
-        project_id: projectId,
-        title: `MR ${id}`,
-        description: 'Description',
-        state: 'opened',
-        created_at: '2024-01-01T00:00:00Z',
-        updated_at: '2024-01-01T00:00:00Z',
-        merged_at: null,
-        closed_at: null,
-        merge_commit_sha: null,
-        web_url: `https://gitlab.example.com/group/project-${projectId}/merge_requests/${id}`,
-        author: createMockUser(),
-        source_branch: 'feature',
-        target_branch: 'main',
-        draft: false,
-        work_in_progress: false,
-        merge_status: 'can_be_merged'
-    };
-}
-function createMockPipeline(id, projectId) {
-    return {
-        id,
-        project_id: projectId,
-        sha: 'sha123',
-        ref: 'main',
-        status: 'success',
-        created_at: '2024-01-01T00:00:00Z',
-        updated_at: '2024-01-01T00:00:00Z',
-        web_url: `https://gitlab.example.com/group/project-${projectId}/pipelines/${id}`,
-        user: createMockUser()
-    };
-}
-function createMockCommit(id) {
-    return {
-        id,
-        short_id: id.substring(0, 8),
-        title: 'Commit message',
-        author_name: 'Mock User',
-        author_email: 'mock@example.com',
-        authored_date: '2024-01-01T00:00:00Z',
-        committer_name: 'Mock User',
-        committer_email: 'mock@example.com',
-        committed_date: '2024-01-01T00:00:00Z',
-        message: 'Commit message',
-        parent_ids: [],
-        web_url: `https://gitlab.example.com/commit/${id}`
-    };
-}
-function createMockLabel(id) {
-    return {
-        id,
-        name: `Label ${id}`,
-        color: '#FF0000',
-        text_color: '#FFFFFF',
-        description: 'Label description',
-        open_issues_count: 0,
-        closed_issues_count: 0,
-        open_merge_requests_count: 0,
-        subscribed: false,
-        priority: null,
-        is_project_label: true
-    };
-}
-function createMockTreeItem(id) {
-    return {
-        id,
-        name: 'file.txt',
-        type: 'blob',
-        path: 'file.txt',
-        mode: '100644'
-    };
-}
-async function validateToolCalls(client, mockServer, expectedToken) {
-    const toolsToTest = [
-        { name: 'get_project', params: { project_id: '1' } },
-        { name: 'list_issues', params: { project_id: '1' } },
-        { name: 'get_merge_request', params: { project_id: '1', merge_request_iid: '1' } },
-        { name: 'list_merge_requests', params: { project_id: '1' } },
-        { name: 'get_repository_tree', params: { project_id: '1' } },
-        { name: 'list_labels', params: { project_id: '1', page: 2, per_page: 50 } },
-        { name: 'list_pipelines', params: { project_id: '1' } },
-        { name: 'list_commits', params: { project_id: '1' } },
-    ];
-    for (const tool of toolsToTest) {
-        mockServer.clearCustomHandlers();
-        let mockPath = '';
-        let mockResponse;
-        switch (tool.name) {
-            case 'get_project':
-                mockPath = '/projects/1';
-                mockResponse = createMockProject(1, 'mock-response');
-                break;
-            case 'list_issues':
-                mockPath = '/projects/1/issues';
-                mockResponse = [createMockIssue(1, 1)];
-                break;
-            case 'get_merge_request':
-                mockPath = '/projects/1/merge_requests/1';
-                mockResponse = createMockMergeRequest(1, 1);
-                break;
-            case 'list_merge_requests':
-                mockPath = '/projects/1/merge_requests';
-                mockResponse = [createMockMergeRequest(1, 1)];
-                break;
-            case 'get_repository_tree':
-                mockPath = '/projects/1/repository/tree';
-                mockResponse = [createMockTreeItem('blob1')];
-                break;
-            case 'list_labels':
-                mockPath = '/projects/1/labels';
-                mockResponse = [createMockLabel(1)];
-                break;
-            case 'list_pipelines':
-                mockPath = '/projects/1/pipelines';
-                mockResponse = [createMockPipeline(1, 1)];
-                break;
-            case 'list_commits':
-                mockPath = '/projects/1/repository/commits';
-                mockResponse = [createMockCommit('sha1')];
-                break;
-            default:
-                throw new Error(`Unknown tool: ${tool.name}`);
-        }
-        mockServer.addMockHandler('get', mockPath, (req, res) => {
-            if (req.headers['authorization']) {
-                assert.strictEqual(req.headers['authorization'], `Bearer ${expectedToken}`);
-            }
-            else {
-                assert.strictEqual(req.headers['private-token'], expectedToken);
-            }
-            if (tool.name === 'list_labels') {
-                assert.strictEqual(req.query.page, '2');
-                assert.strictEqual(req.query.per_page, '50');
-            }
-            res.json(mockResponse);
-        });
-        const result = await client.callTool(tool.name, tool.params);
-        const resultContent = JSON.parse(result.content[0].text);
-        // Basic validation that we got the expected object back
-        if (Array.isArray(mockResponse)) {
-            assert.ok(Array.isArray(resultContent));
-            assert.strictEqual(resultContent.length, mockResponse.length);
-            // Check ID of first item
-            if (resultContent[0].id) {
-                assert.strictEqual(String(resultContent[0].id), String(mockResponse[0].id));
-            }
-        }
-        else {
-            assert.strictEqual(String(resultContent.id), String(mockResponse.id));
-            if (tool.name === 'get_project') {
-                assert.strictEqual(resultContent.description, 'mock-response');
-            }
-        }
-    }
-}

package/build/test/get-merge-request-discussion-schema.test.js

@@ -1,30 +0,0 @@
-import assert from "node:assert/strict";
-import { test } from "node:test";
-import { GetMergeRequestDiscussionSchema, GitLabDiscussionSchema } from "../schemas.js";
-test("get discussion input coerces numeric ids and keeps discussion id", () => {
-    const parsed = GetMergeRequestDiscussionSchema.parse({
-        project_id: 42,
-        merge_request_iid: 7,
-        discussion_id: "abc123",
-    });
-    assert.equal(parsed.project_id, "42");
-    assert.equal(parsed.merge_request_iid, "7");
-    assert.equal(parsed.discussion_id, "abc123");
-});
-test("get discussion input rejects a missing discussion id", () => {
-    assert.throws(() => GetMergeRequestDiscussionSchema.parse({
-        project_id: "42",
-        merge_request_iid: "7",
-    }));
-});
-test("single discussion response parses the GitLab discussion item shape", () => {
-    const parsed = GitLabDiscussionSchema.parse({
-        id: "abc123",
-        individual_note: false,
-        notes: [{ id: 1, body: "please fix", resolvable: true, resolved: false }],
-    });
-    assert.equal(parsed.id, "abc123");
-    assert.equal(parsed.individual_note, false);
-    assert.equal(parsed.notes.length, 1);
-    assert.equal(parsed.notes[0].body, "please fix");
-});

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

@@ -1,112 +0,0 @@
-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/gitlab-artifact-entry-schema.test.js

@@ -1,44 +0,0 @@
-import { describe, it } from "node:test";
-import assert from "node:assert";
-import { GitLabArtifactEntrySchema } from "../schemas.js";
-function validEntry(overrides = {}) {
-    return {
-        name: "report.xml",
-        path: "report.xml",
-        type: "file",
-        ...overrides,
-    };
-}
-describe("When parsing an artifact tree entry", () => {
-    describe("with a string mode", () => {
-        it("should keep the mode", () => {
-            const parsed = GitLabArtifactEntrySchema.parse(validEntry({ mode: "100644", size: 1024 }));
-            assert.strictEqual(parsed.mode, "100644");
-            assert.strictEqual(parsed.size, 1024);
-        });
-    });
-    describe("with mode set to null", () => {
-        it("should accept null", () => {
-            const parsed = GitLabArtifactEntrySchema.parse(validEntry({ mode: null }));
-            assert.strictEqual(parsed.mode, null);
-        });
-    });
-    describe("with size set to null", () => {
-        it("should accept null", () => {
-            const parsed = GitLabArtifactEntrySchema.parse(validEntry({ size: null }));
-            assert.strictEqual(parsed.size, null);
-        });
-    });
-    describe("with mode and size omitted", () => {
-        it("should leave them undefined", () => {
-            const parsed = GitLabArtifactEntrySchema.parse(validEntry());
-            assert.strictEqual(parsed.mode, undefined);
-            assert.strictEqual(parsed.size, undefined);
-        });
-    });
-    describe("with an unknown type", () => {
-        it("should reject the entry", () => {
-            assert.throws(() => GitLabArtifactEntrySchema.parse(validEntry({ type: "symlink" })));
-        });
-    });
-});