@zereight/mcp-gitlab 2.0.34 → 2.0.36

package/build/test/schema-tests.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env ts-node
-import { GetFileContentsSchema, GitLabFileContentSchema, CreatePipelineSchema } from '../schemas.js';
+import { GetFileContentsSchema, GitLabFileContentSchema, CreatePipelineSchema, CreateIssueNoteSchema } from '../schemas.js';
 function runGetFileContentsSchemaTests() {
     console.log('🧪 Testing GetFileContentsSchema...');
     const cases = [
@@ -298,12 +298,86 @@ function runCreatePipelineSchemaTests() {
     console.log(`\nResults: ${passed} passed, ${failed} failed`);
     return { passed, failed };
 }
+function runCreateIssueNoteSchemaTests() {
+    console.log('\n🧪 Testing CreateIssueNoteSchema...');
+    const cases = [
+        {
+            name: 'schema:create_issue_note:top-level-note-without-discussion-id',
+            input: { project_id: 'my/project', issue_iid: '42', body: 'A comment' },
+            expected: { project_id: 'my/project', issue_iid: '42', body: 'A comment', discussion_id: undefined }
+        },
+        {
+            name: 'schema:create_issue_note:reply-with-discussion-id',
+            input: { project_id: 'my/project', issue_iid: '42', discussion_id: 'abc123', body: 'A reply' },
+            expected: { project_id: 'my/project', issue_iid: '42', discussion_id: 'abc123', body: 'A reply' }
+        },
+        {
+            name: 'schema:create_issue_note:with-created-at',
+            input: { project_id: 'my/project', issue_iid: '7', body: 'Note', created_at: '2025-01-01T00:00:00Z' },
+            expected: { project_id: 'my/project', issue_iid: '7', body: 'Note', created_at: '2025-01-01T00:00:00Z' }
+        },
+        {
+            name: 'schema:create_issue_note:numeric-issue-iid-coerced',
+            input: { project_id: 'my/project', issue_iid: 99, body: 'Coerced' },
+            expected: { project_id: 'my/project', issue_iid: '99', body: 'Coerced' }
+        },
+        {
+            name: 'schema:create_issue_note:reject-missing-body',
+            input: { project_id: 'my/project', issue_iid: '1' },
+            shouldFail: true
+        }
+    ];
+    let passed = 0;
+    let failed = 0;
+    cases.forEach(testCase => {
+        const result = {
+            name: testCase.name,
+            status: 'failed'
+        };
+        const parsed = CreateIssueNoteSchema.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 actual === 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 };
+}
 if (import.meta.url === `file://${process.argv[1]}`) {
     const getFileContentsResult = runGetFileContentsSchemaTests();
     const fileContentResult = runGitLabFileContentSchemaTests();
     const createPipelineResult = runCreatePipelineSchemaTests();
-    const totalPassed = getFileContentsResult.passed + fileContentResult.passed + createPipelineResult.passed;
-    const totalFailed = getFileContentsResult.failed + fileContentResult.failed + createPipelineResult.failed;
+    const createIssueNoteResult = runCreateIssueNoteSchemaTests();
+    const totalPassed = getFileContentsResult.passed + fileContentResult.passed + createPipelineResult.passed + createIssueNoteResult.passed;
+    const totalFailed = getFileContentsResult.failed + fileContentResult.failed + createPipelineResult.failed + createIssueNoteResult.failed;
     console.log(`\nTotal Results: ${totalPassed} passed, ${totalFailed} failed`);
     if (totalFailed > 0) {
         process.exit(1);

package/build/test/test-geteffectiveprojectid.js

@@ -11,226 +11,235 @@ import { StreamableHTTPTestClient } from './clients/streamable-http-client.js';
 const MOCK_TOKEN = process.env.GITLAB_TOKEN_TEST || 'glpat-mock-token-12345';
 const DEFAULT_PROJECT_ID = '123';
 const OTHER_PROJECT_ID = '456';
+// Ensure GITLAB_TOKEN_TEST is set for launchServer() validation
+if (!process.env.GITLAB_TOKEN_TEST && !process.env.GITLAB_TOKEN) {
+    process.env.GITLAB_TOKEN_TEST = MOCK_TOKEN;
+}
+if (!process.env.TEST_PROJECT_ID) {
+    process.env.TEST_PROJECT_ID = DEFAULT_PROJECT_ID;
+}
 console.log('🔍 Testing getEffectiveProjectId functionality');
 console.log('');
-describe('getEffectiveProjectId - No GITLAB_ALLOWED_PROJECT_IDS', () => {
-    let mcpUrl;
-    let mockGitLab;
-    let servers = [];
-    let client;
-    before(async () => {
-        // Start mock GitLab server
-        const mockPort = await findMockServerPort(9100);
-        mockGitLab = new MockGitLabServer({
-            port: mockPort,
-            validTokens: [MOCK_TOKEN]
+describe('getEffectiveProjectId', { concurrency: 1 }, () => {
+    describe('getEffectiveProjectId - No GITLAB_ALLOWED_PROJECT_IDS', () => {
+        let mcpUrl;
+        let mockGitLab;
+        let servers = [];
+        let client;
+        before(async () => {
+            // Start mock GitLab server
+            const mockPort = await findMockServerPort(9100);
+            mockGitLab = new MockGitLabServer({
+                port: mockPort,
+                validTokens: [MOCK_TOKEN]
+            });
+            await mockGitLab.start();
+            const mockGitLabUrl = mockGitLab.getUrl();
+            // Start MCP server WITHOUT GITLAB_ALLOWED_PROJECT_IDS
+            const mcpPort = await findAvailablePort(3100);
+            const server = await launchServer({
+                mode: TransportMode.STREAMABLE_HTTP,
+                port: mcpPort,
+                timeout: 5000,
+                env: {
+                    STREAMABLE_HTTP: 'true',
+                    GITLAB_API_URL: `${mockGitLabUrl}/api/v4`,
+                    GITLAB_PROJECT_ID: DEFAULT_PROJECT_ID,
+                    GITLAB_READ_ONLY_MODE: 'true',
+                }
+            });
+            servers.push(server);
+            mcpUrl = `http://${HOST}:${mcpPort}/mcp`;
+            client = new StreamableHTTPTestClient();
+            await client.connect(mcpUrl);
+            console.log(`Mock GitLab: ${mockGitLabUrl}`);
+            console.log(`MCP Server: ${mcpUrl}`);
+            console.log(`Default Project: ${DEFAULT_PROJECT_ID}`);
         });
-        await mockGitLab.start();
-        const mockGitLabUrl = mockGitLab.getUrl();
-        // Start MCP server WITHOUT GITLAB_ALLOWED_PROJECT_IDS
-        const mcpPort = await findAvailablePort(3100);
-        const server = await launchServer({
-            mode: TransportMode.STREAMABLE_HTTP,
-            port: mcpPort,
-            timeout: 5000,
-            env: {
-                STREAMABLE_HTTP: 'true',
-                GITLAB_API_URL: `${mockGitLabUrl}/api/v4`,
-                GITLAB_PROJECT_ID: DEFAULT_PROJECT_ID,
-                GITLAB_READ_ONLY_MODE: 'true',
+        after(async () => {
+            if (client) {
+                await client.disconnect();
+            }
+            cleanupServers(servers);
+            if (mockGitLab) {
+                await mockGitLab.stop();
             }
         });
-        servers.push(server);
-        mcpUrl = `http://${HOST}:${mcpPort}/mcp`;
-        client = new StreamableHTTPTestClient();
-        await client.connect(mcpUrl);
-        console.log(`Mock GitLab: ${mockGitLabUrl}`);
-        console.log(`MCP Server: ${mcpUrl}`);
-        console.log(`Default Project: ${DEFAULT_PROJECT_ID}`);
-    });
-    after(async () => {
-        if (client) {
-            await client.disconnect();
-        }
-        cleanupServers(servers);
-        if (mockGitLab) {
-            await mockGitLab.stop();
-        }
-    });
-    test('should use GITLAB_PROJECT_ID when no project_id is provided', async () => {
-        // Call get_project without specifying project_id
-        const result = await client.callTool('get_project', {
-            project_id: ''
+        test('should use GITLAB_PROJECT_ID when no project_id is provided', async () => {
+            // Call get_project without specifying project_id
+            const result = await client.callTool('get_project', {
+                project_id: ''
+            });
+            assert.ok(result.content, 'Should have content');
+            const content = result.content[0];
+            assert.ok('text' in content, 'Content should have text');
+            const project = JSON.parse(content.text);
+            // The mock server should receive a request for the default project
+            assert.strictEqual(project.id.toString(), DEFAULT_PROJECT_ID, 'Should use GITLAB_PROJECT_ID as default');
+            console.log(`  ✓ Used default project ${DEFAULT_PROJECT_ID} when no project_id provided`);
         });
-        assert.ok(result.content, 'Should have content');
-        const content = result.content[0];
-        assert.ok('text' in content, 'Content should have text');
-        const project = JSON.parse(content.text);
-        // The mock server should receive a request for the default project
-        assert.strictEqual(project.id.toString(), DEFAULT_PROJECT_ID, 'Should use GITLAB_PROJECT_ID as default');
-        console.log(`  ✓ Used default project ${DEFAULT_PROJECT_ID} when no project_id provided`);
-    });
-    test('should prioritize passed project_id over GITLAB_PROJECT_ID', async () => {
-        // Call get_project with a different project_id
-        const result = await client.callTool('get_project', {
-            project_id: OTHER_PROJECT_ID
+        test('should prioritize passed project_id over GITLAB_PROJECT_ID', async () => {
+            // Call get_project with a different project_id
+            const result = await client.callTool('get_project', {
+                project_id: OTHER_PROJECT_ID
+            });
+            assert.ok(result.content, 'Should have content');
+            const content = result.content[0];
+            assert.ok('text' in content, 'Content should have text');
+            const project = JSON.parse(content.text);
+            // Should use the passed project_id, not GITLAB_PROJECT_ID
+            assert.strictEqual(project.id.toString(), OTHER_PROJECT_ID, 'Should use passed project_id');
+            console.log(`  ✓ Used passed project_id ${OTHER_PROJECT_ID} instead of default ${DEFAULT_PROJECT_ID}`);
         });
-        assert.ok(result.content, 'Should have content');
-        const content = result.content[0];
-        assert.ok('text' in content, 'Content should have text');
-        const project = JSON.parse(content.text);
-        // Should use the passed project_id, not GITLAB_PROJECT_ID
-        assert.strictEqual(project.id.toString(), OTHER_PROJECT_ID, 'Should use passed project_id');
-        console.log(`  ✓ Used passed project_id ${OTHER_PROJECT_ID} instead of default ${DEFAULT_PROJECT_ID}`);
     });
-});
-describe('getEffectiveProjectId - With single GITLAB_ALLOWED_PROJECT_IDS', () => {
-    let mcpUrl;
-    let mockGitLab;
-    let servers = [];
-    let client;
-    before(async () => {
-        // Start mock GitLab server
-        const mockPort = await findMockServerPort(9200);
-        mockGitLab = new MockGitLabServer({
-            port: mockPort,
-            validTokens: [MOCK_TOKEN]
+    describe('getEffectiveProjectId - With single GITLAB_ALLOWED_PROJECT_IDS', () => {
+        let mcpUrl;
+        let mockGitLab;
+        let servers = [];
+        let client;
+        before(async () => {
+            // Start mock GitLab server
+            const mockPort = await findMockServerPort(9200);
+            mockGitLab = new MockGitLabServer({
+                port: mockPort,
+                validTokens: [MOCK_TOKEN]
+            });
+            await mockGitLab.start();
+            const mockGitLabUrl = mockGitLab.getUrl();
+            // Start MCP server WITH single GITLAB_ALLOWED_PROJECT_IDS
+            const mcpPort = await findAvailablePort(3200);
+            const server = await launchServer({
+                mode: TransportMode.STREAMABLE_HTTP,
+                port: mcpPort,
+                timeout: 5000,
+                env: {
+                    STREAMABLE_HTTP: 'true',
+                    GITLAB_API_URL: `${mockGitLabUrl}/api/v4`,
+                    GITLAB_PROJECT_ID: DEFAULT_PROJECT_ID,
+                    GITLAB_ALLOWED_PROJECT_IDS: DEFAULT_PROJECT_ID,
+                    GITLAB_READ_ONLY_MODE: 'true',
+                }
+            });
+            servers.push(server);
+            mcpUrl = `http://${HOST}:${mcpPort}/mcp`;
+            client = new StreamableHTTPTestClient();
+            await client.connect(mcpUrl);
+            console.log(`Mock GitLab: ${mockGitLabUrl}`);
+            console.log(`MCP Server: ${mcpUrl}`);
+            console.log(`Allowed Project: ${DEFAULT_PROJECT_ID}`);
         });
-        await mockGitLab.start();
-        const mockGitLabUrl = mockGitLab.getUrl();
-        // Start MCP server WITH single GITLAB_ALLOWED_PROJECT_IDS
-        const mcpPort = await findAvailablePort(3200);
-        const server = await launchServer({
-            mode: TransportMode.STREAMABLE_HTTP,
-            port: mcpPort,
-            timeout: 5000,
-            env: {
-                STREAMABLE_HTTP: 'true',
-                GITLAB_API_URL: `${mockGitLabUrl}/api/v4`,
-                GITLAB_PROJECT_ID: DEFAULT_PROJECT_ID,
-                GITLAB_ALLOWED_PROJECT_IDS: DEFAULT_PROJECT_ID,
-                GITLAB_READ_ONLY_MODE: 'true',
+        after(async () => {
+            if (client) {
+                await client.disconnect();
+            }
+            cleanupServers(servers);
+            if (mockGitLab) {
+                await mockGitLab.stop();
             }
         });
-        servers.push(server);
-        mcpUrl = `http://${HOST}:${mcpPort}/mcp`;
-        client = new StreamableHTTPTestClient();
-        await client.connect(mcpUrl);
-        console.log(`Mock GitLab: ${mockGitLabUrl}`);
-        console.log(`MCP Server: ${mcpUrl}`);
-        console.log(`Allowed Project: ${DEFAULT_PROJECT_ID}`);
-    });
-    after(async () => {
-        if (client) {
-            await client.disconnect();
-        }
-        cleanupServers(servers);
-        if (mockGitLab) {
-            await mockGitLab.stop();
-        }
-    });
-    test('should use single allowed project as default', async () => {
-        const result = await client.callTool('get_project', {
-            project_id: ''
+        test('should use single allowed project as default', async () => {
+            const result = await client.callTool('get_project', {
+                project_id: ''
+            });
+            assert.ok(result.content, 'Should have content');
+            const content = result.content[0];
+            assert.ok('text' in content, 'Content should have text');
+            const project = JSON.parse(content.text);
+            assert.strictEqual(project.id.toString(), DEFAULT_PROJECT_ID, 'Should use allowed project as default');
+            console.log(`  ✓ Used allowed project ${DEFAULT_PROJECT_ID} as default`);
+        });
+        test('should reject access to non-allowed project', async () => {
+            try {
+                await client.callTool('get_project', {
+                    project_id: OTHER_PROJECT_ID
+                });
+                assert.fail('Should have rejected access to non-allowed project');
+            }
+            catch (error) {
+                assert.ok(error instanceof Error);
+                assert.ok(error.message.includes('Access denied'), 'Should indicate access denied');
+                console.log('  ✓ Correctly rejected access to non-allowed project');
+            }
         });
-        assert.ok(result.content, 'Should have content');
-        const content = result.content[0];
-        assert.ok('text' in content, 'Content should have text');
-        const project = JSON.parse(content.text);
-        assert.strictEqual(project.id.toString(), DEFAULT_PROJECT_ID, 'Should use allowed project as default');
-        console.log(`  ✓ Used allowed project ${DEFAULT_PROJECT_ID} as default`);
     });
-    test('should reject access to non-allowed project', async () => {
-        try {
-            await client.callTool('get_project', {
-                project_id: OTHER_PROJECT_ID
+    describe('getEffectiveProjectId - With multiple GITLAB_ALLOWED_PROJECT_IDS', () => {
+        let mcpUrl;
+        let mockGitLab;
+        let servers = [];
+        let client;
+        before(async () => {
+            // Start mock GitLab server
+            const mockPort = await findMockServerPort(9300);
+            mockGitLab = new MockGitLabServer({
+                port: mockPort,
+                validTokens: [MOCK_TOKEN]
             });
-            assert.fail('Should have rejected access to non-allowed project');
-        }
-        catch (error) {
-            assert.ok(error instanceof Error);
-            assert.ok(error.message.includes('Access denied'), 'Should indicate access denied');
-            console.log('  ✓ Correctly rejected access to non-allowed project');
-        }
-    });
-});
-describe('getEffectiveProjectId - With multiple GITLAB_ALLOWED_PROJECT_IDS', () => {
-    let mcpUrl;
-    let mockGitLab;
-    let servers = [];
-    let client;
-    before(async () => {
-        // Start mock GitLab server
-        const mockPort = await findMockServerPort(9300);
-        mockGitLab = new MockGitLabServer({
-            port: mockPort,
-            validTokens: [MOCK_TOKEN]
+            await mockGitLab.start();
+            const mockGitLabUrl = mockGitLab.getUrl();
+            // Start MCP server WITH multiple GITLAB_ALLOWED_PROJECT_IDS
+            const mcpPort = await findAvailablePort(3300);
+            const server = await launchServer({
+                mode: TransportMode.STREAMABLE_HTTP,
+                port: mcpPort,
+                timeout: 5000,
+                env: {
+                    STREAMABLE_HTTP: 'true',
+                    GITLAB_API_URL: `${mockGitLabUrl}/api/v4`,
+                    GITLAB_ALLOWED_PROJECT_IDS: `${DEFAULT_PROJECT_ID},${OTHER_PROJECT_ID}`,
+                    GITLAB_READ_ONLY_MODE: 'true',
+                }
+            });
+            servers.push(server);
+            mcpUrl = `http://${HOST}:${mcpPort}/mcp`;
+            client = new StreamableHTTPTestClient();
+            await client.connect(mcpUrl);
+            console.log(`Mock GitLab: ${mockGitLabUrl}`);
+            console.log(`MCP Server: ${mcpUrl}`);
+            console.log(`Allowed Projects: ${DEFAULT_PROJECT_ID},${OTHER_PROJECT_ID}`);
         });
-        await mockGitLab.start();
-        const mockGitLabUrl = mockGitLab.getUrl();
-        // Start MCP server WITH multiple GITLAB_ALLOWED_PROJECT_IDS
-        const mcpPort = await findAvailablePort(3300);
-        const server = await launchServer({
-            mode: TransportMode.STREAMABLE_HTTP,
-            port: mcpPort,
-            timeout: 5000,
-            env: {
-                STREAMABLE_HTTP: 'true',
-                GITLAB_API_URL: `${mockGitLabUrl}/api/v4`,
-                GITLAB_ALLOWED_PROJECT_IDS: `${DEFAULT_PROJECT_ID},${OTHER_PROJECT_ID}`,
-                GITLAB_READ_ONLY_MODE: 'true',
+        after(async () => {
+            if (client) {
+                await client.disconnect();
+            }
+            cleanupServers(servers);
+            if (mockGitLab) {
+                await mockGitLab.stop();
             }
         });
-        servers.push(server);
-        mcpUrl = `http://${HOST}:${mcpPort}/mcp`;
-        client = new StreamableHTTPTestClient();
-        await client.connect(mcpUrl);
-        console.log(`Mock GitLab: ${mockGitLabUrl}`);
-        console.log(`MCP Server: ${mcpUrl}`);
-        console.log(`Allowed Projects: ${DEFAULT_PROJECT_ID},${OTHER_PROJECT_ID}`);
-    });
-    after(async () => {
-        if (client) {
-            await client.disconnect();
-        }
-        cleanupServers(servers);
-        if (mockGitLab) {
-            await mockGitLab.stop();
-        }
-    });
-    test('should require explicit project_id when multiple projects allowed', async () => {
-        try {
-            await client.callTool('get_project', {
-                project_id: ''
+        test('should require explicit project_id when multiple projects allowed', async () => {
+            try {
+                await client.callTool('get_project', {
+                    project_id: ''
+                });
+                assert.fail('Should have required explicit project_id');
+            }
+            catch (error) {
+                assert.ok(error instanceof Error);
+                assert.ok(error.message.includes('Please specify a project ID'), 'Should require project ID');
+                console.log('  ✓ Correctly required explicit project_id');
+            }
+        });
+        test('should allow access to first allowed project', async () => {
+            const result = await client.callTool('get_project', {
+                project_id: DEFAULT_PROJECT_ID
             });
-            assert.fail('Should have required explicit project_id');
-        }
-        catch (error) {
-            assert.ok(error instanceof Error);
-            assert.ok(error.message.includes('Please specify a project ID'), 'Should require project ID');
-            console.log('  ✓ Correctly required explicit project_id');
-        }
-    });
-    test('should allow access to first allowed project', async () => {
-        const result = await client.callTool('get_project', {
-            project_id: DEFAULT_PROJECT_ID
+            assert.ok(result.content, 'Should have content');
+            const content = result.content[0];
+            assert.ok('text' in content, 'Content should have text');
+            const project = JSON.parse(content.text);
+            assert.strictEqual(project.id.toString(), DEFAULT_PROJECT_ID, 'Should allow first project');
+            console.log(`  ✓ Allowed access to first project ${DEFAULT_PROJECT_ID}`);
         });
-        assert.ok(result.content, 'Should have content');
-        const content = result.content[0];
-        assert.ok('text' in content, 'Content should have text');
-        const project = JSON.parse(content.text);
-        assert.strictEqual(project.id.toString(), DEFAULT_PROJECT_ID, 'Should allow first project');
-        console.log(`  ✓ Allowed access to first project ${DEFAULT_PROJECT_ID}`);
-    });
-    test('should allow access to second allowed project', async () => {
-        const result = await client.callTool('get_project', {
-            project_id: OTHER_PROJECT_ID
+        test('should allow access to second allowed project', async () => {
+            const result = await client.callTool('get_project', {
+                project_id: OTHER_PROJECT_ID
+            });
+            assert.ok(result.content, 'Should have content');
+            const content = result.content[0];
+            assert.ok('text' in content, 'Content should have text');
+            const project = JSON.parse(content.text);
+            assert.strictEqual(project.id.toString(), OTHER_PROJECT_ID, 'Should allow second project');
+            console.log(`  ✓ Allowed access to second project ${OTHER_PROJECT_ID}`);
         });
-        assert.ok(result.content, 'Should have content');
-        const content = result.content[0];
-        assert.ok('text' in content, 'Content should have text');
-        const project = JSON.parse(content.text);
-        assert.strictEqual(project.id.toString(), OTHER_PROJECT_ID, 'Should allow second project');
-        console.log(`  ✓ Allowed access to second project ${OTHER_PROJECT_ID}`);
     });
-});
+}); // end wrapper describe