@forestadmin/mcp-server 0.1.0

package/dist/server.test.js

@@ -0,0 +1,901 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const jsonwebtoken_1 = __importDefault(require("jsonwebtoken"));
+const supertest_1 = __importDefault(require("supertest"));
+const server_1 = __importDefault(require("./server"));
+const mock_server_1 = __importDefault(require("./test-utils/mock-server"));
+function shutDownHttpServer(server) {
+    if (!server)
+        return Promise.resolve();
+    return new Promise(resolve => {
+        server.close(() => {
+            resolve();
+        });
+    });
+}
+/**
+ * Integration tests for ForestMCPServer instance
+ * Tests the actual server class and its behavior
+ */
+describe('ForestMCPServer Instance', () => {
+    let server;
+    let originalEnv;
+    let modifiedEnv;
+    let mockServer;
+    const originalFetch = global.fetch;
+    beforeAll(() => {
+        originalEnv = { ...process.env };
+        process.env.FOREST_ENV_SECRET = 'test-env-secret';
+        process.env.FOREST_AUTH_SECRET = 'test-auth-secret';
+        process.env.FOREST_SERVER_URL = 'https://test.forestadmin.com';
+        process.env.AGENT_HOSTNAME = 'http://localhost:3310';
+        // Setup mock for Forest Admin server
+        mockServer = new mock_server_1.default();
+        mockServer
+            .get('/liana/environment', {
+            data: { id: '12345', attributes: { api_endpoint: 'https://api.example.com' } },
+        })
+            .get('/liana/forest-schema', {
+            data: [
+                {
+                    id: 'users',
+                    type: 'collections',
+                    attributes: { name: 'users', fields: [{ field: 'id', type: 'Number' }] },
+                },
+                {
+                    id: 'products',
+                    type: 'collections',
+                    attributes: { name: 'products', fields: [{ field: 'name', type: 'String' }] },
+                },
+            ],
+            meta: { liana: 'forest-express-sequelize', liana_version: '9.0.0', liana_features: null },
+        })
+            .get(/\/oauth\/register\/registered-client/, {
+            client_id: 'registered-client',
+            redirect_uris: ['https://example.com/callback'],
+            client_name: 'Test Client',
+        })
+            .get(/\/oauth\/register\//, { error: 'Client not found' }, 404);
+        global.fetch = mockServer.fetch;
+    });
+    afterAll(async () => {
+        process.env = originalEnv;
+        global.fetch = originalFetch;
+    });
+    beforeEach(() => {
+        modifiedEnv = { ...process.env };
+        mockServer.clear();
+    });
+    afterEach(async () => {
+        process.env = modifiedEnv;
+    });
+    describe('constructor', () => {
+        it('should create server instance', () => {
+            server = new server_1.default();
+            expect(server).toBeDefined();
+            expect(server).toBeInstanceOf(server_1.default);
+        });
+        it('should initialize with FOREST_SERVER_URL', () => {
+            process.env.FOREST_SERVER_URL = 'https://custom.forestadmin.com';
+            server = new server_1.default();
+            expect(server.forestServerUrl).toBe('https://custom.forestadmin.com');
+        });
+        it('should fallback to FOREST_URL', () => {
+            delete process.env.FOREST_SERVER_URL;
+            process.env.FOREST_URL = 'https://fallback.forestadmin.com';
+            server = new server_1.default();
+            expect(server.forestServerUrl).toBe('https://fallback.forestadmin.com');
+        });
+        it('should use default URL when neither is provided', () => {
+            delete process.env.FOREST_SERVER_URL;
+            delete process.env.FOREST_URL;
+            server = new server_1.default();
+            expect(server.forestServerUrl).toBe('https://api.forestadmin.com');
+        });
+        it('should create MCP server instance', () => {
+            server = new server_1.default();
+            expect(server.mcpServer).toBeDefined();
+        });
+    });
+    describe('environment validation', () => {
+        it('should throw error when FOREST_ENV_SECRET is missing', async () => {
+            delete process.env.FOREST_ENV_SECRET;
+            server = new server_1.default();
+            await expect(server.run()).rejects.toThrow('FOREST_ENV_SECRET is not set. Provide it via options.envSecret or FOREST_ENV_SECRET environment variable.');
+        });
+        it('should throw error when FOREST_AUTH_SECRET is missing', async () => {
+            delete process.env.FOREST_AUTH_SECRET;
+            server = new server_1.default();
+            await expect(server.run()).rejects.toThrow('FOREST_AUTH_SECRET is not set. Provide it via options.authSecret or FOREST_AUTH_SECRET environment variable.');
+        });
+    });
+    describe('run method', () => {
+        afterEach(async () => {
+            await shutDownHttpServer(server?.httpServer);
+        });
+        it('should start server on specified port', async () => {
+            const testPort = 39310; // Use a different port for testing
+            process.env.MCP_SERVER_PORT = testPort.toString();
+            server = new server_1.default();
+            // Start the server without awaiting (it runs indefinitely)
+            server.run();
+            // Wait a bit for the server to start
+            await new Promise(resolve => {
+                setTimeout(resolve, 500);
+            });
+            // Verify the server is running by making a request
+            const { httpServer } = server;
+            expect(httpServer).toBeDefined();
+            // Make a request to verify server is responding
+            const response = await (0, supertest_1.default)(httpServer)
+                .post('/mcp')
+                .send({ jsonrpc: '2.0', method: 'tools/list', id: 1 });
+            expect(response.status).toBeDefined();
+        });
+        it('should create transport instance', async () => {
+            const testPort = 39311;
+            process.env.MCP_SERVER_PORT = testPort.toString();
+            server = new server_1.default();
+            server.run();
+            await new Promise(resolve => {
+                setTimeout(resolve, 500);
+            });
+            expect(server.mcpTransport).toBeDefined();
+        });
+    });
+    describe('HTTP endpoint', () => {
+        let httpServer;
+        beforeAll(async () => {
+            const testPort = 39312;
+            process.env.MCP_SERVER_PORT = testPort.toString();
+            server = new server_1.default();
+            server.run();
+            await new Promise(resolve => {
+                setTimeout(resolve, 500);
+            });
+            httpServer = server.httpServer;
+        });
+        afterAll(async () => {
+            await shutDownHttpServer(server?.httpServer);
+        });
+        it('should handle POST requests to /mcp', async () => {
+            const response = await (0, supertest_1.default)(httpServer)
+                .post('/mcp')
+                .send({ jsonrpc: '2.0', method: 'initialize', id: 1 });
+            expect(response.status).not.toBe(404);
+        });
+        it('should reject GET requests', async () => {
+            const response = await (0, supertest_1.default)(httpServer).get('/mcp');
+            expect(response.status).toBe(405);
+        });
+        it('should handle CORS', async () => {
+            const response = await (0, supertest_1.default)(httpServer)
+                .post('/mcp')
+                .set('Origin', 'https://example.com')
+                .send({ jsonrpc: '2.0', method: 'initialize', id: 1 });
+            expect(response.headers['access-control-allow-origin']).toBe('*');
+        });
+        it('should return JSON-RPC error on transport failure', async () => {
+            // Send invalid request
+            const response = await (0, supertest_1.default)(httpServer).post('/mcp').send('invalid json');
+            // Should handle the error gracefully
+            expect(response.status).toBeGreaterThanOrEqual(400);
+        });
+        describe('OAuth metadata endpoint', () => {
+            it('should return OAuth metadata at /.well-known/oauth-authorization-server', async () => {
+                const response = await (0, supertest_1.default)(server.httpServer).get('/.well-known/oauth-authorization-server');
+                expect(response.status).toBe(200);
+                expect(response.headers['content-type']).toMatch(/application\/json/);
+                expect(response.body.issuer).toBe('http://localhost:39312/');
+                expect(response.body.registration_endpoint).toBe('https://test.forestadmin.com/oauth/register');
+                expect(response.body.authorization_endpoint).toBe(`http://localhost:39312/oauth/authorize`);
+                expect(response.body.token_endpoint).toBe(`http://localhost:39312/oauth/token`);
+                expect(response.body.revocation_endpoint).toBeUndefined();
+                expect(response.body.scopes_supported).toEqual([
+                    'mcp:read',
+                    'mcp:write',
+                    'mcp:action',
+                    'mcp:admin',
+                ]);
+                expect(response.body.response_types_supported).toEqual(['code']);
+                expect(response.body.grant_types_supported).toEqual([
+                    'authorization_code',
+                    'refresh_token',
+                ]);
+                expect(response.body.code_challenge_methods_supported).toEqual(['S256']);
+                expect(response.body.token_endpoint_auth_methods_supported).toEqual(['none']);
+            });
+            it('should return registration_endpoint with custom FOREST_SERVER_URL', async () => {
+                // Clean up previous server
+                await shutDownHttpServer(server?.httpServer);
+                process.env.FOREST_SERVER_URL = 'https://custom.forestadmin.com';
+                process.env.MCP_SERVER_PORT = '39314';
+                server = new server_1.default();
+                server.run();
+                await new Promise(resolve => {
+                    setTimeout(resolve, 500);
+                });
+                const response = await (0, supertest_1.default)(server.httpServer).get('/.well-known/oauth-authorization-server');
+                expect(response.body.registration_endpoint).toBe('https://custom.forestadmin.com/oauth/register');
+            });
+        });
+        describe('/oauth/authorize endpoint', () => {
+            it('should return 400 when required parameters are missing', async () => {
+                const response = await (0, supertest_1.default)(httpServer).get('/oauth/authorize');
+                expect(response.status).toBe(400);
+            });
+            it('should return 400 when client_id is missing', async () => {
+                const response = await (0, supertest_1.default)(httpServer).get('/oauth/authorize').query({
+                    redirect_uri: 'https://example.com/callback',
+                    response_type: 'code',
+                    code_challenge: 'test-challenge',
+                    code_challenge_method: 'S256',
+                    state: 'test-state',
+                });
+                expect(response.status).toBe(400);
+            });
+            it('should return 400 when redirect_uri is missing', async () => {
+                const response = await (0, supertest_1.default)(httpServer).get('/oauth/authorize').query({
+                    client_id: 'test-client',
+                    response_type: 'code',
+                    code_challenge: 'test-challenge',
+                    code_challenge_method: 'S256',
+                    state: 'test-state',
+                });
+                expect(response.status).toBe(400);
+            });
+            it('should return 400 when code_challenge is missing', async () => {
+                const response = await (0, supertest_1.default)(httpServer).get('/oauth/authorize').query({
+                    client_id: 'test-client',
+                    redirect_uri: 'https://example.com/callback',
+                    response_type: 'code',
+                    code_challenge_method: 'S256',
+                    state: 'test-state',
+                });
+                expect(response.status).toBe(400);
+            });
+            it('should return 400 when client is not registered', async () => {
+                const response = await (0, supertest_1.default)(httpServer).get('/oauth/authorize').query({
+                    client_id: 'unregistered-client',
+                    redirect_uri: 'https://example.com/callback',
+                    response_type: 'code',
+                    code_challenge: 'test-challenge',
+                    code_challenge_method: 'S256',
+                    state: 'test-state',
+                    scope: 'mcp:read',
+                });
+                expect(response.status).toBe(400);
+            });
+            it('should redirect to Forest Admin frontend with correct parameters', async () => {
+                const response = await (0, supertest_1.default)(httpServer).get('/oauth/authorize').query({
+                    client_id: 'registered-client',
+                    redirect_uri: 'https://example.com/callback',
+                    response_type: 'code',
+                    code_challenge: 'test-challenge',
+                    code_challenge_method: 'S256',
+                    state: 'test-state',
+                    scope: 'mcp:read profile',
+                });
+                expect(response.status).toBe(302);
+                expect(response.headers.location).toContain('https://app.forestadmin.com/oauth/authorize');
+                const redirectUrl = new URL(response.headers.location);
+                expect(redirectUrl.searchParams.get('redirect_uri')).toBe('https://example.com/callback');
+                expect(redirectUrl.searchParams.get('code_challenge')).toBe('test-challenge');
+                expect(redirectUrl.searchParams.get('code_challenge_method')).toBe('S256');
+                expect(redirectUrl.searchParams.get('response_type')).toBe('code');
+                expect(redirectUrl.searchParams.get('client_id')).toBe('registered-client');
+                expect(redirectUrl.searchParams.get('state')).toBe('test-state');
+                expect(redirectUrl.searchParams.get('scope')).toBe('mcp:read+profile');
+                expect(redirectUrl.searchParams.get('environmentId')).toBe('12345');
+            });
+            it('should redirect to default frontend when FOREST_FRONTEND_HOSTNAME is not set', async () => {
+                const response = await (0, supertest_1.default)(httpServer).get('/oauth/authorize').query({
+                    client_id: 'registered-client',
+                    redirect_uri: 'https://example.com/callback',
+                    response_type: 'code',
+                    code_challenge: 'test-challenge',
+                    code_challenge_method: 'S256',
+                    state: 'test-state',
+                    scope: 'mcp:read',
+                });
+                expect(response.status).toBe(302);
+                expect(response.headers.location).toContain('https://app.forestadmin.com/oauth/authorize');
+            });
+            it('should handle POST method for authorize', async () => {
+                // POST /authorize uses form-encoded body
+                const response = await (0, supertest_1.default)(httpServer).post('/oauth/authorize').type('form').send({
+                    client_id: 'registered-client',
+                    redirect_uri: 'https://example.com/callback',
+                    response_type: 'code',
+                    code_challenge: 'test-challenge',
+                    code_challenge_method: 'S256',
+                    state: 'test-state',
+                    scope: 'mcp:read',
+                    resource: 'https://example.com/resource',
+                });
+                expect(response.status).toBe(302);
+                expect(response.headers.location).toStrictEqual(`https://app.forestadmin.com/oauth/authorize?redirect_uri=${encodeURIComponent('https://example.com/callback')}&code_challenge=test-challenge&code_challenge_method=S256&response_type=code&client_id=registered-client&state=test-state&scope=${encodeURIComponent('mcp:read')}&resource=${encodeURIComponent('https://example.com/resource')}&environmentId=12345`);
+            });
+        });
+    });
+    /**
+     * Integration tests for /oauth/token endpoint
+     * Uses a separate server instance with mock server for Forest Admin API
+     */
+    describe('/oauth/token endpoint', () => {
+        let mcpServer;
+        let mcpHttpServer;
+        let mcpMockServer;
+        beforeAll(async () => {
+            process.env.FOREST_ENV_SECRET = 'test-env-secret';
+            process.env.FOREST_AUTH_SECRET = 'test-auth-secret';
+            process.env.FOREST_SERVER_URL = 'https://test.forestadmin.com';
+            process.env.MCP_SERVER_PORT = '39320';
+            // Setup mock for Forest Admin server API responses
+            mcpMockServer = new mock_server_1.default();
+            mcpMockServer
+                .get('/liana/environment', {
+                data: { id: '12345', attributes: { api_endpoint: 'https://api.example.com' } },
+            })
+                .get('/liana/forest-schema', {
+                data: [
+                    {
+                        id: 'users',
+                        type: 'collections',
+                        attributes: { name: 'users', fields: [{ field: 'id', type: 'Number' }] },
+                    },
+                    {
+                        id: 'products',
+                        type: 'collections',
+                        attributes: { name: 'products', fields: [{ field: 'name', type: 'String' }] },
+                    },
+                ],
+                meta: { liana: 'forest-express-sequelize', liana_version: '9.0.0', liana_features: null },
+            })
+                .get(/\/oauth\/register\/registered-client/, {
+                client_id: 'registered-client',
+                redirect_uris: ['https://example.com/callback'],
+                client_name: 'Test Client',
+                scope: 'mcp:read mcp:write',
+            })
+                .get(/\/oauth\/register\//, { error: 'Client not found' }, 404)
+                // Mock Forest Admin OAuth token endpoint - returns valid JWTs with meta.renderingId, exp, iat, scope
+                // access_token JWT payload: { meta: { renderingId: 456 }, scope: 'mcp:read mcp:write', iat: 2524608000, exp: 2524611600 }
+                // refresh_token JWT payload: { iat: 2524608000, exp: 2525212800 }
+                .post('/oauth/token', {
+                access_token: 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJtZXRhIjp7InJlbmRlcmluZ0lkIjo0NTZ9LCJzY29wZSI6Im1jcDpyZWFkIG1jcDp3cml0ZSIsImlhdCI6MjUyNDYwODAwMCwiZXhwIjoyNTI0NjExNjAwfQ.fake',
+                refresh_token: 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpYXQiOjI1MjQ2MDgwMDAsImV4cCI6MjUyNTIxMjgwMH0.fake',
+                expires_in: 3600,
+                token_type: 'Bearer',
+                scope: 'mcp:read mcp:write',
+            })
+                // Mock Forest Admin user info endpoint (called by forestadmin-client via superagent)
+                .get(/\/liana\/v2\/renderings\/\d+\/authorization/, {
+                data: {
+                    id: '123',
+                    attributes: {
+                        email: 'user@example.com',
+                        first_name: 'Test',
+                        last_name: 'User',
+                        teams: ['Operations'],
+                        role: 'Admin',
+                        permission_level: 'admin',
+                        tags: [],
+                    },
+                },
+            });
+            global.fetch = mcpMockServer.fetch;
+            // Also mock superagent for forestadmin-client requests
+            mcpMockServer.setupSuperagentMock();
+            // Create and start server
+            mcpServer = new server_1.default();
+            mcpServer.run();
+            await new Promise(resolve => {
+                setTimeout(resolve, 500);
+            });
+            mcpHttpServer = mcpServer.httpServer;
+        });
+        afterAll(async () => {
+            mcpMockServer.restoreSuperagent();
+            await new Promise(resolve => {
+                if (mcpServer?.httpServer) {
+                    mcpServer.httpServer.close(() => resolve());
+                }
+                else {
+                    resolve();
+                }
+            });
+        });
+        it('should return 400 when grant_type is missing', async () => {
+            const response = await (0, supertest_1.default)(mcpHttpServer).post('/oauth/token').type('form').send({
+                code: 'auth-code-123',
+                redirect_uri: 'https://example.com/callback',
+                client_id: 'registered-client',
+            });
+            expect(response.status).toBe(400);
+            expect(response.body.error).toBe('invalid_request');
+        });
+        it('should return 400 when code is missing', async () => {
+            const response = await (0, supertest_1.default)(mcpHttpServer).post('/oauth/token').type('form').send({
+                grant_type: 'authorization_code',
+                redirect_uri: 'https://example.com/callback',
+                client_id: 'registered-client',
+            });
+            expect(response.status).toBe(400);
+            expect(response.body.error).toBe('invalid_request');
+        });
+        it('should call Forest Admin server to exchange code', async () => {
+            mcpMockServer.clear();
+            const response = await (0, supertest_1.default)(mcpHttpServer).post('/oauth/token').type('form').send({
+                grant_type: 'authorization_code',
+                code: 'valid-auth-code',
+                redirect_uri: 'https://example.com/callback',
+                client_id: 'registered-client',
+                code_verifier: 'test-code-verifier',
+            });
+            expect(mcpMockServer.fetch).toHaveBeenCalledWith('https://test.forestadmin.com/oauth/token', expect.objectContaining({
+                method: 'POST',
+                body: expect.stringContaining('"grant_type":"authorization_code"'),
+            }));
+            expect(response.status).toBe(200);
+            expect(response.body.access_token).toBeDefined();
+            expect(response.body.refresh_token).toBeDefined();
+            expect(response.body.token_type).toBe('Bearer');
+            // expires_in is calculated as exp - now from the JWT, so it's a large value for our test tokens
+            expect(response.body.expires_in).toBeGreaterThan(0);
+            // The scope is returned from the decoded forest token
+            expect(response.body.scope).toBe('mcp:read mcp:write');
+            const accessToken = response.body.access_token;
+            expect(() => jsonwebtoken_1.default.verify(accessToken, process.env.FOREST_AUTH_SECRET)).not.toThrow();
+            // The forestadmin-client transforms the response from the API
+            // (e.g., first_name → firstName, id string → number, teams[0] → team)
+            const decoded = jsonwebtoken_1.default.decode(accessToken);
+            expect(decoded).toMatchObject({
+                id: 123,
+                email: 'user@example.com',
+                firstName: 'Test',
+                lastName: 'User',
+                team: 'Operations',
+                role: 'Admin',
+                permissionLevel: 'admin',
+                renderingId: 456,
+                tags: {},
+                serverToken: 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJtZXRhIjp7InJlbmRlcmluZ0lkIjo0NTZ9LCJzY29wZSI6Im1jcDpyZWFkIG1jcDp3cml0ZSIsImlhdCI6MjUyNDYwODAwMCwiZXhwIjoyNTI0NjExNjAwfQ.fake',
+            });
+            // JWT should also have iat and exp claims
+            expect(decoded.iat).toBeDefined();
+            expect(decoded.exp).toBeDefined();
+            // Verify refresh token structure
+            const refreshToken = response.body.refresh_token;
+            const decodedRefreshToken = jsonwebtoken_1.default.decode(refreshToken);
+            expect(decodedRefreshToken).toMatchObject({
+                type: 'refresh',
+                clientId: 'registered-client',
+                userId: 123,
+                renderingId: 456,
+                // The serverRefreshToken is the JWT returned from Forest Admin
+                serverRefreshToken: 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpYXQiOjI1MjQ2MDgwMDAsImV4cCI6MjUyNTIxMjgwMH0.fake',
+            });
+        });
+        it('should exchange refresh token for new tokens', async () => {
+            mcpMockServer.clear();
+            // First, get initial tokens
+            const initialResponse = await (0, supertest_1.default)(mcpHttpServer).post('/oauth/token').type('form').send({
+                grant_type: 'authorization_code',
+                code: 'valid-auth-code',
+                redirect_uri: 'https://example.com/callback',
+                client_id: 'registered-client',
+                code_verifier: 'test-code-verifier',
+            });
+            expect(initialResponse.status).toBe(200);
+            const refreshToken = initialResponse.body.refresh_token;
+            // Clear mock to track new calls
+            mcpMockServer.clear();
+            // Now exchange refresh token for new tokens
+            const refreshResponse = await (0, supertest_1.default)(mcpHttpServer).post('/oauth/token').type('form').send({
+                grant_type: 'refresh_token',
+                refresh_token: refreshToken,
+                client_id: 'registered-client',
+            });
+            expect(refreshResponse.status).toBe(200);
+            expect(refreshResponse.body.access_token).toBeDefined();
+            expect(refreshResponse.body.refresh_token).toBeDefined();
+            expect(refreshResponse.body.token_type).toBe('Bearer');
+            // expires_in is calculated as exp - now from the JWT (duration in seconds)
+            expect(refreshResponse.body.expires_in).toBeGreaterThan(0);
+            // Verify the new access token is valid
+            const newAccessToken = refreshResponse.body.access_token;
+            expect(() => jsonwebtoken_1.default.verify(newAccessToken, process.env.FOREST_AUTH_SECRET)).not.toThrow();
+            // Verify token rotation: new refresh token is returned
+            const newRefreshToken = refreshResponse.body.refresh_token;
+            expect(newRefreshToken).toBeDefined();
+            // Verify it's a valid JWT with refresh token structure
+            const decodedNewRefresh = jsonwebtoken_1.default.decode(newRefreshToken);
+            expect(decodedNewRefresh.type).toBe('refresh');
+            expect(decodedNewRefresh.clientId).toBe('registered-client');
+            // Verify Forest Admin token endpoint was called with refresh_token grant
+            expect(mcpMockServer.fetch).toHaveBeenCalledWith('https://test.forestadmin.com/oauth/token', expect.objectContaining({
+                method: 'POST',
+                body: expect.stringContaining('"grant_type":"refresh_token"'),
+            }));
+            // Note: Token rotation is implemented - the new refresh token should be different
+            // However, since both requests use the same mock returning the same forest-server-refresh-token,
+            // the generated JWT will have similar claims but different iat/exp timestamps
+            const oldDecoded = jsonwebtoken_1.default.decode(refreshToken);
+            const newDecoded = jsonwebtoken_1.default.decode(newRefreshToken);
+            expect(newDecoded.iat).toBeGreaterThanOrEqual(oldDecoded.iat);
+        });
+        it('should return 400 for invalid refresh token', async () => {
+            const response = await (0, supertest_1.default)(mcpHttpServer).post('/oauth/token').type('form').send({
+                grant_type: 'refresh_token',
+                refresh_token: 'invalid-token',
+                client_id: 'registered-client',
+            });
+            expect(response.status).toBe(400);
+            expect(response.body.error).toBeDefined();
+        });
+        it('should return 400 when refresh_token is missing for refresh_token grant', async () => {
+            const response = await (0, supertest_1.default)(mcpHttpServer).post('/oauth/token').type('form').send({
+                grant_type: 'refresh_token',
+                client_id: 'registered-client',
+            });
+            expect(response.status).toBe(400);
+        });
+        it('should return 400 when client_id does not match refresh token', async () => {
+            // Create a refresh token for a different client
+            const refreshToken = jsonwebtoken_1.default.sign({
+                type: 'refresh',
+                clientId: 'different-client',
+                userId: 123,
+                renderingId: 456,
+                serverRefreshToken: 'forest-refresh-token',
+            }, process.env.FOREST_AUTH_SECRET, { expiresIn: '7d' });
+            const response = await (0, supertest_1.default)(mcpHttpServer).post('/oauth/token').type('form').send({
+                grant_type: 'refresh_token',
+                refresh_token: refreshToken,
+                client_id: 'registered-client',
+            });
+            expect(response.status).toBe(400);
+            expect(response.body.error).toBeDefined();
+        });
+        describe('error handling', () => {
+            const setupErrorMock = (errorResponse, statusCode) => {
+                mcpMockServer.reset();
+                mcpMockServer
+                    .get('/liana/environment', {
+                    data: { id: '12345', attributes: { api_endpoint: 'https://api.example.com' } },
+                })
+                    .get('/liana/forest-schema', {
+                    data: [
+                        {
+                            id: 'users',
+                            type: 'collections',
+                            attributes: { name: 'users', fields: [{ field: 'id', type: 'Number' }] },
+                        },
+                    ],
+                    meta: {
+                        liana: 'forest-express-sequelize',
+                        liana_version: '9.0.0',
+                        liana_features: null,
+                    },
+                })
+                    .get(/\/oauth\/register\/registered-client/, {
+                    client_id: 'registered-client',
+                    redirect_uris: ['https://example.com/callback'],
+                    client_name: 'Test Client',
+                    scope: 'mcp:read mcp:write',
+                })
+                    .get(/\/oauth\/register\//, { error: 'Client not found' }, 404)
+                    .post('/oauth/token', errorResponse, statusCode);
+            };
+            // Note: The implementation wraps all OAuth errors in InvalidRequestError,
+            // so the error code is always 'invalid_request' with the original error in the description
+            it('should return error when authorization code is invalid', async () => {
+                setupErrorMock({
+                    error: 'invalid_grant',
+                    error_description: 'The authorization code has expired or is invalid',
+                }, 400);
+                const response = await (0, supertest_1.default)(mcpHttpServer).post('/oauth/token').type('form').send({
+                    grant_type: 'authorization_code',
+                    code: 'expired-or-invalid-code',
+                    redirect_uri: 'https://example.com/callback',
+                    client_id: 'registered-client',
+                    code_verifier: 'test-code-verifier',
+                });
+                expect(response.status).toBe(400);
+                expect(response.body.error).toBe('invalid_request');
+                expect(response.body.error_description).toContain('Failed to exchange authorization code');
+            });
+            it('should return error when client authentication fails', async () => {
+                setupErrorMock({
+                    error: 'invalid_client',
+                    error_description: 'Client authentication failed',
+                }, 401);
+                const response = await (0, supertest_1.default)(mcpHttpServer).post('/oauth/token').type('form').send({
+                    grant_type: 'authorization_code',
+                    code: 'some-code',
+                    redirect_uri: 'https://example.com/callback',
+                    client_id: 'registered-client',
+                    code_verifier: 'test-code-verifier',
+                });
+                expect(response.status).toBe(400);
+                expect(response.body.error).toBe('invalid_request');
+                expect(response.body.error_description).toContain('Failed to exchange authorization code');
+            });
+            it('should return error when requested scope is invalid', async () => {
+                setupErrorMock({
+                    error: 'invalid_scope',
+                    error_description: 'The requested scope is invalid or unknown',
+                }, 400);
+                const response = await (0, supertest_1.default)(mcpHttpServer).post('/oauth/token').type('form').send({
+                    grant_type: 'authorization_code',
+                    code: 'some-code',
+                    redirect_uri: 'https://example.com/callback',
+                    client_id: 'registered-client',
+                    code_verifier: 'test-code-verifier',
+                });
+                expect(response.status).toBe(400);
+                expect(response.body.error).toBe('invalid_request');
+                expect(response.body.error_description).toContain('Failed to exchange authorization code');
+            });
+            it('should return error when client is not authorized', async () => {
+                setupErrorMock({
+                    error: 'unauthorized_client',
+                    error_description: 'The client is not authorized to use this grant type',
+                }, 403);
+                const response = await (0, supertest_1.default)(mcpHttpServer).post('/oauth/token').type('form').send({
+                    grant_type: 'authorization_code',
+                    code: 'some-code',
+                    redirect_uri: 'https://example.com/callback',
+                    client_id: 'registered-client',
+                    code_verifier: 'test-code-verifier',
+                });
+                expect(response.status).toBe(400);
+                expect(response.body.error).toBe('invalid_request');
+                expect(response.body.error_description).toContain('Failed to exchange authorization code');
+            });
+            it('should return error when Forest Admin server has internal error', async () => {
+                setupErrorMock({
+                    error: 'server_error',
+                    error_description: 'An unexpected error occurred on the server',
+                }, 500);
+                const response = await (0, supertest_1.default)(mcpHttpServer).post('/oauth/token').type('form').send({
+                    grant_type: 'authorization_code',
+                    code: 'some-code',
+                    redirect_uri: 'https://example.com/callback',
+                    client_id: 'registered-client',
+                    code_verifier: 'test-code-verifier',
+                });
+                expect(response.status).toBe(400);
+                expect(response.body.error).toBe('invalid_request');
+                expect(response.body.error_description).toContain('Failed to exchange authorization code');
+            });
+            it('should use default error description when not provided by Forest server', async () => {
+                setupErrorMock({ error: 'invalid_request' }, 400);
+                const response = await (0, supertest_1.default)(mcpHttpServer).post('/oauth/token').type('form').send({
+                    grant_type: 'authorization_code',
+                    code: 'some-code',
+                    redirect_uri: 'https://example.com/callback',
+                    client_id: 'registered-client',
+                    code_verifier: 'test-code-verifier',
+                });
+                expect(response.status).toBe(400);
+                expect(response.body.error).toBe('invalid_request');
+                expect(response.body.error_description).toContain('Failed to exchange authorization code');
+            });
+            it('should return error when Forest server returns error without error code', async () => {
+                setupErrorMock({ message: 'Something went wrong' }, 500);
+                const response = await (0, supertest_1.default)(mcpHttpServer).post('/oauth/token').type('form').send({
+                    grant_type: 'authorization_code',
+                    code: 'some-code',
+                    redirect_uri: 'https://example.com/callback',
+                    client_id: 'registered-client',
+                    code_verifier: 'test-code-verifier',
+                });
+                expect(response.status).toBe(400);
+                expect(response.body.error).toBe('invalid_request');
+                expect(response.body.error_description).toContain('Failed to exchange authorization code');
+            });
+        });
+    });
+    /**
+     * Integration tests for the list tool
+     * Tests that the list tool is properly registered and accessible
+     */
+    describe('List tool integration', () => {
+        let listServer;
+        let listHttpServer;
+        let listMockServer;
+        beforeAll(async () => {
+            process.env.FOREST_ENV_SECRET = 'test-env-secret';
+            process.env.FOREST_AUTH_SECRET = 'test-auth-secret';
+            process.env.FOREST_SERVER_URL = 'https://test.forestadmin.com';
+            process.env.AGENT_HOSTNAME = 'http://localhost:3310';
+            process.env.MCP_SERVER_PORT = '39330';
+            listMockServer = new mock_server_1.default();
+            listMockServer
+                .get('/liana/environment', {
+                data: { id: '12345', attributes: { api_endpoint: 'https://api.example.com' } },
+            })
+                .get('/liana/forest-schema', {
+                data: [
+                    {
+                        id: 'users',
+                        type: 'collections',
+                        attributes: { name: 'users', fields: [{ field: 'id', type: 'Number' }] },
+                    },
+                    {
+                        id: 'products',
+                        type: 'collections',
+                        attributes: { name: 'products', fields: [{ field: 'name', type: 'String' }] },
+                    },
+                ],
+                meta: { liana: 'forest-express-sequelize', liana_version: '9.0.0', liana_features: null },
+            })
+                .get(/\/oauth\/register\/registered-client/, {
+                client_id: 'registered-client',
+                redirect_uris: ['https://example.com/callback'],
+                client_name: 'Test Client',
+                scope: 'mcp:read mcp:write',
+            })
+                .get(/\/oauth\/register\//, { error: 'Client not found' }, 404);
+            global.fetch = listMockServer.fetch;
+            listServer = new server_1.default();
+            listServer.run();
+            await new Promise(resolve => {
+                setTimeout(resolve, 500);
+            });
+            listHttpServer = listServer.httpServer;
+        });
+        afterAll(async () => {
+            await new Promise(resolve => {
+                if (listServer?.httpServer) {
+                    listServer.httpServer.close(() => resolve());
+                }
+                else {
+                    resolve();
+                }
+            });
+        });
+        it('should have list tool registered in the MCP server', () => {
+            expect(listServer.mcpServer).toBeDefined();
+            // The tool should be registered during server initialization
+            // We verify this by checking the server started successfully
+            expect(listHttpServer).toBeDefined();
+        });
+        it('should require authentication to access /mcp endpoint', async () => {
+            const response = await (0, supertest_1.default)(listHttpServer).post('/mcp').send({
+                jsonrpc: '2.0',
+                method: 'tools/list',
+                id: 1,
+            });
+            // Without a valid bearer token, we should get an authentication error
+            expect(response.status).toBe(401);
+        });
+        it('should reject requests with invalid bearer token', async () => {
+            const response = await (0, supertest_1.default)(listHttpServer)
+                .post('/mcp')
+                .set('Authorization', 'Bearer invalid-token')
+                .send({
+                jsonrpc: '2.0',
+                method: 'tools/list',
+                id: 1,
+            });
+            expect(response.status).toBe(401);
+        });
+        it('should accept requests with valid bearer token and list available tools', async () => {
+            // Create a valid JWT token
+            const authSecret = process.env.FOREST_AUTH_SECRET || 'test-auth-secret';
+            const validToken = jsonwebtoken_1.default.sign({
+                id: 123,
+                email: 'user@example.com',
+                renderingId: 456,
+            }, authSecret, { expiresIn: '1h' });
+            const response = await (0, supertest_1.default)(listHttpServer)
+                .post('/mcp')
+                .set('Authorization', `Bearer ${validToken}`)
+                .set('Content-Type', 'application/json')
+                .set('Accept', 'application/json, text/event-stream')
+                .send({
+                jsonrpc: '2.0',
+                method: 'tools/list',
+                id: 1,
+            });
+            expect(response.status).toBe(200);
+            // The MCP SDK returns the response as text that needs to be parsed
+            // The response may be in JSON-RPC format or as a newline-delimited JSON stream
+            let responseData;
+            if (response.body && Object.keys(response.body).length > 0) {
+                responseData = response.body;
+            }
+            else {
+                // Parse the text response - MCP returns Server-Sent Events format with "data: " prefix
+                const textResponse = response.text;
+                const lines = textResponse.split('\n').filter((line) => line.trim());
+                // Find the line with the actual JSON-RPC response (starts with "data: ")
+                const dataLine = lines.find((line) => line.startsWith('data: '));
+                if (dataLine) {
+                    responseData = JSON.parse(dataLine.replace('data: ', ''));
+                }
+                else {
+                    responseData = JSON.parse(lines[lines.length - 1]);
+                }
+            }
+            expect(responseData.jsonrpc).toBe('2.0');
+            expect(responseData.id).toBe(1);
+            expect(responseData.result).toBeDefined();
+            expect(responseData.result.tools).toBeDefined();
+            expect(Array.isArray(responseData.result.tools)).toBe(true);
+            // Verify the 'list' tool is registered
+            const listTool = responseData.result.tools.find((tool) => tool.name === 'list');
+            expect(listTool).toBeDefined();
+            expect(listTool.description).toBe('Retrieve a list of records from the specified collection.');
+            expect(listTool.inputSchema).toBeDefined();
+            expect(listTool.inputSchema.properties).toHaveProperty('collectionName');
+            expect(listTool.inputSchema.properties).toHaveProperty('search');
+            expect(listTool.inputSchema.properties).toHaveProperty('filters');
+            expect(listTool.inputSchema.properties).toHaveProperty('sort');
+            // Verify collectionName has enum with the collection names from the mocked schema
+            const collectionNameSchema = listTool.inputSchema.properties.collectionName;
+            expect(collectionNameSchema.type).toBe('string');
+            expect(collectionNameSchema.enum).toBeDefined();
+            expect(collectionNameSchema.enum).toEqual(['users', 'products']);
+        });
+        it('should create activity log with forestServerToken when calling list tool', async () => {
+            // This test verifies that the activity log API is called with the forestServerToken
+            // (the original Forest server token) and NOT the MCP JWT token.
+            // The forestServerToken is embedded in the MCP JWT during token exchange and extracted
+            // by verifyAccessToken into authInfo.extra.forestServerToken
+            const authSecret = process.env.FOREST_AUTH_SECRET || 'test-auth-secret';
+            const forestServerToken = 'original-forest-server-token-for-activity-log';
+            // Create MCP JWT with embedded serverToken (as done during OAuth token exchange)
+            const mcpToken = jsonwebtoken_1.default.sign({
+                id: 123,
+                email: 'user@example.com',
+                renderingId: 456,
+                serverToken: forestServerToken,
+            }, authSecret, { expiresIn: '1h' });
+            // Setup mock to capture the activity log API call and mock agent response
+            listMockServer.clear();
+            listMockServer
+                .post('/api/activity-logs-requests', { success: true })
+                .post('/forest/rpc', { result: [{ id: 1, name: 'Test' }] });
+            const response = await (0, supertest_1.default)(listHttpServer)
+                .post('/mcp')
+                .set('Authorization', `Bearer ${mcpToken}`)
+                .set('Content-Type', 'application/json')
+                .set('Accept', 'application/json, text/event-stream')
+                .send({
+                jsonrpc: '2.0',
+                method: 'tools/call',
+                params: {
+                    name: 'list',
+                    arguments: { collectionName: 'users' },
+                },
+                id: 2,
+            });
+            // The tool call should succeed (or fail on agent call, but activity log should be created first)
+            expect(response.status).toBe(200);
+            // Verify activity log API was called with the correct forestServerToken
+            // The mock fetch captures all calls as [url, options] tuples
+            const activityLogCall = listMockServer.fetch.mock.calls.find((call) => call[0] === 'https://test.forestadmin.com/api/activity-logs-requests');
+            expect(activityLogCall).toBeDefined();
+            expect(activityLogCall[1].headers).toMatchObject({
+                Authorization: `Bearer ${forestServerToken}`,
+                'Content-Type': 'application/json',
+                'Forest-Application-Source': 'MCP',
+            });
+            // Verify the body contains the correct data
+            const body = JSON.parse(activityLogCall[1].body);
+            expect(body.data.attributes.action).toBe('index');
+            expect(body.data.relationships.collection.data).toEqual({
+                id: 'users',
+                type: 'collections',
+            });
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"server.test.js","sourceRoot":"","sources":["../src/server.test.ts"],"names":[],"mappings":"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"}