@forestadmin/mcp-server 0.1.0

package/dist/forest-oauth-provider.test.js

@@ -0,0 +1,590 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const forestadmin_client_1 = __importDefault(require("@forestadmin/forestadmin-client"));
+const jsonwebtoken_1 = __importDefault(require("jsonwebtoken"));
+const forest_oauth_provider_1 = __importDefault(require("./forest-oauth-provider"));
+const mock_server_1 = __importDefault(require("./test-utils/mock-server"));
+jest.mock('jsonwebtoken');
+jest.mock('@forestadmin/forestadmin-client');
+const mockCreateForestAdminClient = forestadmin_client_1.default;
+const mockJwtDecode = jsonwebtoken_1.default.decode;
+const mockJwtSign = jsonwebtoken_1.default.sign;
+const TEST_ENV_SECRET = 'test-env-secret';
+const TEST_AUTH_SECRET = 'test-auth-secret';
+const TEST_FOREST_APP_URL = 'https://app.forestadmin.com';
+function createProvider(forestServerUrl = 'https://api.forestadmin.com') {
+    return new forest_oauth_provider_1.default({
+        forestServerUrl,
+        forestAppUrl: TEST_FOREST_APP_URL,
+        envSecret: TEST_ENV_SECRET,
+        authSecret: TEST_AUTH_SECRET,
+        logger: console.info,
+    });
+}
+describe('ForestOAuthProvider', () => {
+    let originalEnv;
+    let mockServer;
+    const originalFetch = global.fetch;
+    beforeAll(() => {
+        originalEnv = { ...process.env };
+    });
+    afterAll(() => {
+        process.env = originalEnv;
+        global.fetch = originalFetch;
+    });
+    beforeEach(() => {
+        process.env.FOREST_ENV_SECRET = TEST_ENV_SECRET;
+        process.env.FOREST_AUTH_SECRET = TEST_AUTH_SECRET;
+        mockServer = new mock_server_1.default();
+    });
+    afterEach(() => {
+        mockServer.reset();
+    });
+    describe('constructor', () => {
+        it('should create instance with forestServerUrl', () => {
+            const customProvider = createProvider('https://custom.forestadmin.com');
+            expect(customProvider).toBeDefined();
+        });
+        it('should create instance with custom forestAppUrl', () => {
+            const customProvider = new forest_oauth_provider_1.default({
+                forestServerUrl: 'https://api.forestadmin.com',
+                forestAppUrl: 'https://custom-app.forestadmin.com',
+                envSecret: TEST_ENV_SECRET,
+                authSecret: TEST_AUTH_SECRET,
+                logger: console.info,
+            });
+            expect(customProvider).toBeDefined();
+        });
+    });
+    describe('initialize', () => {
+        it('should not throw when envSecret is empty string', async () => {
+            const customProvider = new forest_oauth_provider_1.default({
+                forestServerUrl: 'https://api.forestadmin.com',
+                forestAppUrl: TEST_FOREST_APP_URL,
+                envSecret: '',
+                authSecret: TEST_AUTH_SECRET,
+                logger: console.info,
+            });
+            await expect(customProvider.initialize()).resolves.not.toThrow();
+        });
+        it('should fetch environmentId from Forest Admin API', async () => {
+            mockServer.get('/liana/environment', {
+                data: { id: '98765', attributes: { api_endpoint: 'https://api.example.com' } },
+            });
+            global.fetch = mockServer.fetch;
+            const testProvider = createProvider();
+            await testProvider.initialize();
+            // Verify fetch was called with correct URL and headers
+            expect(mockServer.fetch).toHaveBeenCalledWith('https://api.forestadmin.com/liana/environment', expect.objectContaining({
+                method: 'GET',
+                headers: expect.objectContaining({
+                    'forest-secret-key': 'test-env-secret',
+                    'Content-Type': 'application/json',
+                }),
+            }));
+        });
+        it('should set environmentId after successful initialization', async () => {
+            mockServer.get('/liana/environment', {
+                data: { id: '54321', attributes: { api_endpoint: 'https://api.example.com' } },
+            });
+            global.fetch = mockServer.fetch;
+            const testProvider = createProvider();
+            await testProvider.initialize();
+            // Verify environmentId is set by checking authorize redirect includes it
+            const mockResponse = { redirect: jest.fn() };
+            const mockClient = {
+                client_id: 'test-client',
+                redirect_uris: ['https://example.com/callback'],
+            };
+            await testProvider.authorize(mockClient, {
+                redirectUri: 'https://example.com/callback',
+                codeChallenge: 'challenge',
+                state: 'state',
+                scopes: ['mcp:read'],
+                resource: new URL('https://localhost:3931'),
+            }, mockResponse);
+            const redirectUrl = new URL(mockResponse.redirect.mock.calls[0][0]);
+            expect(redirectUrl.searchParams.get('environmentId')).toBe('54321');
+        });
+        it('should handle non-OK response from Forest Admin API', async () => {
+            mockServer.get('/liana/environment', { error: 'Unauthorized' }, 401);
+            global.fetch = mockServer.fetch;
+            const loggerSpy = jest.fn();
+            const testProvider = new forest_oauth_provider_1.default({
+                forestServerUrl: 'https://api.forestadmin.com',
+                forestAppUrl: TEST_FOREST_APP_URL,
+                envSecret: TEST_ENV_SECRET,
+                authSecret: TEST_AUTH_SECRET,
+                logger: loggerSpy,
+            });
+            await testProvider.initialize();
+            expect(loggerSpy).toHaveBeenCalledWith('Warn', expect.stringContaining('Failed to fetch environmentId from Forest Admin API'));
+        });
+        it('should handle fetch network errors gracefully', async () => {
+            global.fetch = jest.fn().mockRejectedValue(new Error('Network error'));
+            const loggerSpy = jest.fn();
+            const testProvider = new forest_oauth_provider_1.default({
+                forestServerUrl: 'https://api.forestadmin.com',
+                forestAppUrl: TEST_FOREST_APP_URL,
+                envSecret: TEST_ENV_SECRET,
+                authSecret: TEST_AUTH_SECRET,
+                logger: loggerSpy,
+            });
+            await testProvider.initialize();
+            expect(loggerSpy).toHaveBeenCalledWith('Warn', expect.stringContaining('Failed to fetch environmentId from Forest Admin API'));
+        });
+        it('should use correct forest server URL for API call', async () => {
+            mockServer.get('/liana/environment', {
+                data: { id: '11111', attributes: { api_endpoint: 'https://api.example.com' } },
+            });
+            global.fetch = mockServer.fetch;
+            const testProvider = createProvider('https://custom.forestadmin.com');
+            await testProvider.initialize();
+            expect(mockServer.fetch).toHaveBeenCalledWith('https://custom.forestadmin.com/liana/environment', expect.any(Object));
+        });
+    });
+    describe('clientsStore.getClient', () => {
+        it('should fetch client from Forest Admin API', async () => {
+            const clientData = {
+                client_id: 'test-client-123',
+                redirect_uris: ['https://example.com/callback'],
+                client_name: 'Test Client',
+            };
+            mockServer.get('/oauth/register/test-client-123', clientData);
+            global.fetch = mockServer.fetch;
+            const provider = createProvider();
+            const client = await provider.clientsStore.getClient('test-client-123');
+            expect(client).toEqual(clientData);
+            expect(mockServer.fetch).toHaveBeenCalledWith('https://api.forestadmin.com/oauth/register/test-client-123', expect.objectContaining({
+                method: 'GET',
+                headers: expect.objectContaining({
+                    'Content-Type': 'application/json',
+                }),
+            }));
+        });
+        it('should return undefined when client is not found', async () => {
+            mockServer.get('/oauth/register/unknown-client', { error: 'Not found' }, 404);
+            global.fetch = mockServer.fetch;
+            const provider = createProvider();
+            const client = await provider.clientsStore.getClient('unknown-client');
+            expect(client).toBeUndefined();
+        });
+        it('should return undefined on server error', async () => {
+            mockServer.get('/oauth/register/error-client', { error: 'Internal error' }, 500);
+            global.fetch = mockServer.fetch;
+            const provider = createProvider();
+            const client = await provider.clientsStore.getClient('error-client');
+            expect(client).toBeUndefined();
+        });
+    });
+    describe('authorize', () => {
+        let mockResponse;
+        let mockClient;
+        let initializedProvider;
+        beforeEach(async () => {
+            mockResponse = {
+                redirect: jest.fn(),
+            };
+            mockClient = {
+                client_id: 'test-client-id',
+                redirect_uris: ['https://example.com/callback'],
+            };
+            // Create provider and mock the fetch to set environmentId
+            initializedProvider = createProvider();
+            // Mock fetch to return a valid response
+            const mockFetch = jest.fn().mockResolvedValue({
+                ok: true,
+                json: () => Promise.resolve({
+                    data: { id: '12345', attributes: { api_endpoint: 'https://api.example.com' } },
+                }),
+            });
+            global.fetch = mockFetch;
+            await initializedProvider.initialize();
+        });
+        afterEach(() => {
+            jest.restoreAllMocks();
+        });
+        it('should redirect to Forest Admin authentication URL', async () => {
+            await initializedProvider.authorize(mockClient, {
+                redirectUri: 'https://example.com/callback',
+                codeChallenge: 'test-code-challenge',
+                state: 'test-state',
+                scopes: ['mcp:read', 'profile'],
+                resource: new URL('https://localhost:3931'),
+            }, mockResponse);
+            expect(mockResponse.redirect).toHaveBeenCalledWith(expect.stringContaining('https://app.forestadmin.com/oauth/authorize'));
+        });
+        it('should include all required query parameters in redirect URL', async () => {
+            await initializedProvider.authorize(mockClient, {
+                redirectUri: 'https://example.com/callback',
+                codeChallenge: 'test-code-challenge',
+                state: 'test-state',
+                scopes: ['mcp:read', 'profile'],
+                resource: new URL('https://localhost:3931'),
+            }, mockResponse);
+            const redirectCall = mockResponse.redirect.mock.calls[0][0];
+            const url = new URL(redirectCall);
+            expect(url.hostname).toBe('app.forestadmin.com');
+            expect(url.pathname).toBe('/oauth/authorize');
+            expect(url.searchParams.get('redirect_uri')).toBe('https://example.com/callback');
+            expect(url.searchParams.get('code_challenge')).toBe('test-code-challenge');
+            expect(url.searchParams.get('code_challenge_method')).toBe('S256');
+            expect(url.searchParams.get('response_type')).toBe('code');
+            expect(url.searchParams.get('client_id')).toBe('test-client-id');
+            expect(url.searchParams.get('state')).toBe('test-state');
+            expect(url.searchParams.get('scope')).toBe('mcp:read+profile');
+            expect(url.searchParams.get('environmentId')).toBe('12345');
+        });
+        it('should redirect to error URL when environmentId is not set', async () => {
+            // Create a provider without initializing (environmentId is undefined)
+            const uninitializedProvider = createProvider();
+            await uninitializedProvider.authorize(mockClient, {
+                redirectUri: 'https://example.com/callback',
+                codeChallenge: 'test-code-challenge',
+                state: 'test-state',
+                scopes: ['mcp:read'],
+                resource: new URL('https://localhost:3931'),
+            }, mockResponse);
+            const redirectCall = mockResponse.redirect.mock.calls[0][0];
+            expect(redirectCall).toContain('https://example.com/callback');
+            expect(redirectCall).toContain('error=server_error');
+        });
+        it('should use custom forestAppUrl for redirect', async () => {
+            const customAppUrl = 'https://custom-app.forestadmin.com';
+            const customProvider = new forest_oauth_provider_1.default({
+                forestServerUrl: 'https://api.forestadmin.com',
+                forestAppUrl: customAppUrl,
+                envSecret: TEST_ENV_SECRET,
+                authSecret: TEST_AUTH_SECRET,
+                logger: console.info,
+            });
+            // Mock fetch to return a valid response for initialize
+            global.fetch = jest.fn().mockResolvedValue({
+                ok: true,
+                json: () => Promise.resolve({
+                    data: { id: '12345', attributes: { api_endpoint: 'https://api.example.com' } },
+                }),
+            });
+            await customProvider.initialize();
+            await customProvider.authorize(mockClient, {
+                redirectUri: 'https://example.com/callback',
+                codeChallenge: 'test-code-challenge',
+                state: 'test-state',
+                scopes: ['mcp:read'],
+                resource: new URL('https://localhost:3931'),
+            }, mockResponse);
+            const redirectCall = mockResponse.redirect.mock.calls[0][0];
+            const url = new URL(redirectCall);
+            expect(url.hostname).toBe('custom-app.forestadmin.com');
+            expect(url.pathname).toBe('/oauth/authorize');
+        });
+    });
+    describe('exchangeAuthorizationCode', () => {
+        let mockClient;
+        let mockGetUserInfo;
+        beforeEach(() => {
+            mockClient = {
+                client_id: 'test-client-id',
+                redirect_uris: ['https://example.com/callback'],
+                scope: 'mcp:read mcp:write',
+            };
+            // Setup mock for forestAdminClient
+            mockGetUserInfo = jest.fn().mockResolvedValue({
+                id: 123,
+                email: 'user@example.com',
+                firstName: 'Test',
+                lastName: 'User',
+                team: 'Operations',
+                role: 'Admin',
+                tags: {},
+                renderingId: 456,
+                permissionLevel: 'admin',
+            });
+            mockCreateForestAdminClient.mockReturnValue({
+                authService: {
+                    getUserInfo: mockGetUserInfo,
+                },
+            });
+            // Setup mock for jsonwebtoken - decode is called twice:
+            // first for access token, then for refresh token
+            const now = Math.floor(Date.now() / 1000);
+            mockJwtDecode
+                .mockReturnValueOnce({
+                meta: { renderingId: 456 },
+                exp: now + 3600, // expires in 1 hour
+                iat: now,
+                scope: 'mcp:read',
+            })
+                .mockReturnValueOnce({
+                exp: now + 604800, // expires in 7 days
+                iat: now,
+            });
+            mockJwtSign.mockReturnValue('mocked-jwt-token');
+        });
+        afterEach(() => {
+            jest.clearAllMocks();
+        });
+        it('should exchange authorization code with Forest Admin server', async () => {
+            mockServer
+                .get('/liana/environment', {
+                data: { id: '12345', attributes: { api_endpoint: 'https://api.example.com' } },
+            })
+                .post('/oauth/token', {
+                access_token: 'forest-access-token',
+                refresh_token: 'forest-refresh-token',
+                expires_in: 3600,
+                token_type: 'Bearer',
+                scope: 'mcp:read',
+            });
+            global.fetch = mockServer.fetch;
+            const provider = createProvider();
+            const result = await provider.exchangeAuthorizationCode(mockClient, 'auth-code-123', 'code-verifier-456', 'https://example.com/callback');
+            expect(mockServer.fetch).toHaveBeenCalledWith('https://api.forestadmin.com/oauth/token', expect.objectContaining({
+                method: 'POST',
+                headers: expect.objectContaining({
+                    'Content-Type': 'application/json',
+                    'forest-secret-key': 'test-env-secret',
+                }),
+                body: JSON.stringify({
+                    grant_type: 'authorization_code',
+                    code: 'auth-code-123',
+                    redirect_uri: 'https://example.com/callback',
+                    client_id: 'test-client-id',
+                    code_verifier: 'code-verifier-456',
+                }),
+            }));
+            expect(result.access_token).toBe('mocked-jwt-token');
+            expect(result.refresh_token).toBe('mocked-jwt-token');
+            expect(result.token_type).toBe('Bearer');
+            // expires_in is calculated as exp - now, so it should be approximately 3600
+            expect(result.expires_in).toBeGreaterThan(3590);
+            expect(result.expires_in).toBeLessThanOrEqual(3600);
+            expect(result.scope).toBe('mcp:read');
+            expect(mockJwtDecode).toHaveBeenCalledWith('forest-access-token');
+            expect(mockJwtDecode).toHaveBeenCalledWith('forest-refresh-token');
+            expect(mockGetUserInfo).toHaveBeenCalledWith(456, 'forest-access-token');
+            // First call: access token - expiresIn is calculated as exp - now, so it's approximately 3600
+            expect(mockJwtSign).toHaveBeenCalledWith(expect.objectContaining({
+                id: 123,
+                email: 'user@example.com',
+                serverToken: 'forest-access-token',
+            }), 'test-auth-secret', { expiresIn: expect.any(Number) });
+            // Second call: refresh token - expiresIn is calculated as exp - now, so it's approximately 604800
+            expect(mockJwtSign).toHaveBeenCalledWith(expect.objectContaining({
+                type: 'refresh',
+                clientId: 'test-client-id',
+                userId: 123,
+                renderingId: 456,
+                serverRefreshToken: 'forest-refresh-token',
+            }), 'test-auth-secret', { expiresIn: expect.any(Number) });
+        });
+        it('should throw error when token exchange fails', async () => {
+            mockServer
+                .get('/liana/environment', {
+                data: { id: '12345', attributes: { api_endpoint: 'https://api.example.com' } },
+            })
+                .post('/oauth/token', { error: 'invalid_grant' }, 400);
+            global.fetch = mockServer.fetch;
+            const provider = createProvider();
+            await expect(provider.exchangeAuthorizationCode(mockClient, 'invalid-code', 'code-verifier', 'https://example.com/callback')).rejects.toThrow('Failed to exchange authorization code');
+        });
+    });
+    describe('exchangeRefreshToken', () => {
+        let mockClient;
+        let mockGetUserInfo;
+        beforeEach(() => {
+            mockClient = {
+                client_id: 'test-client-id',
+                redirect_uris: ['https://example.com/callback'],
+                scope: 'mcp:read mcp:write',
+            };
+            mockGetUserInfo = jest.fn().mockResolvedValue({
+                id: 123,
+                email: 'user@example.com',
+                firstName: 'Test',
+                lastName: 'User',
+                team: 'Operations',
+                role: 'Admin',
+                tags: {},
+                renderingId: 456,
+                permissionLevel: 'admin',
+            });
+            mockCreateForestAdminClient.mockReturnValue({
+                authService: {
+                    getUserInfo: mockGetUserInfo,
+                },
+            });
+            mockJwtSign.mockReturnValue('new-mocked-jwt-token');
+        });
+        afterEach(() => {
+            jest.clearAllMocks();
+        });
+        it('should exchange refresh token for new tokens', async () => {
+            // Mock jwt.verify to return decoded refresh token
+            jsonwebtoken_1.default.verify.mockReturnValue({
+                type: 'refresh',
+                clientId: 'test-client-id',
+                userId: 123,
+                renderingId: 456,
+                serverRefreshToken: 'forest-refresh-token',
+            });
+            // Mock jwt.decode - called twice: first for access token, then for refresh token
+            const now = Math.floor(Date.now() / 1000);
+            mockJwtDecode
+                .mockReturnValueOnce({
+                meta: { renderingId: 456 },
+                exp: now + 3600, // expires in 1 hour
+                iat: now,
+                scope: 'mcp:read',
+            })
+                .mockReturnValueOnce({
+                exp: now + 604800, // expires in 7 days
+                iat: now,
+            });
+            mockServer.post('/oauth/token', {
+                access_token: 'new-forest-access-token',
+                refresh_token: 'new-forest-refresh-token',
+                expires_in: 3600,
+                token_type: 'Bearer',
+                scope: 'mcp:read',
+            });
+            global.fetch = mockServer.fetch;
+            const provider = createProvider();
+            const result = await provider.exchangeRefreshToken(mockClient, 'valid-refresh-token');
+            expect(result.access_token).toBe('new-mocked-jwt-token');
+            expect(result.refresh_token).toBe('new-mocked-jwt-token');
+            expect(result.token_type).toBe('Bearer');
+            // expires_in is calculated as exp - now, so it should be approximately 3600
+            expect(result.expires_in).toBeGreaterThan(3590);
+            expect(result.expires_in).toBeLessThanOrEqual(3600);
+            expect(mockServer.fetch).toHaveBeenCalledWith('https://api.forestadmin.com/oauth/token', expect.objectContaining({
+                method: 'POST',
+                body: JSON.stringify({
+                    grant_type: 'refresh_token',
+                    refresh_token: 'forest-refresh-token',
+                    client_id: 'test-client-id',
+                }),
+            }));
+        });
+        it('should throw error for invalid refresh token', async () => {
+            jsonwebtoken_1.default.verify.mockImplementation(() => {
+                throw new Error('invalid signature');
+            });
+            const provider = createProvider();
+            await expect(provider.exchangeRefreshToken(mockClient, 'invalid-refresh-token')).rejects.toThrow('Invalid or expired refresh token');
+        });
+        it('should throw error when token type is not refresh', async () => {
+            jsonwebtoken_1.default.verify.mockReturnValue({
+                type: 'access',
+                clientId: 'test-client-id',
+            });
+            const provider = createProvider();
+            await expect(provider.exchangeRefreshToken(mockClient, 'access-token')).rejects.toThrow('Invalid token type');
+        });
+        it('should throw error when client_id does not match', async () => {
+            jsonwebtoken_1.default.verify.mockReturnValue({
+                type: 'refresh',
+                clientId: 'different-client-id',
+                userId: 123,
+                renderingId: 456,
+                serverRefreshToken: 'forest-refresh-token',
+            });
+            const provider = createProvider();
+            await expect(provider.exchangeRefreshToken(mockClient, 'refresh-token-for-different-client')).rejects.toThrow('Token was not issued to this client');
+        });
+        it('should throw error when Forest Admin refresh fails', async () => {
+            jsonwebtoken_1.default.verify.mockReturnValue({
+                type: 'refresh',
+                clientId: 'test-client-id',
+                userId: 123,
+                renderingId: 456,
+                serverRefreshToken: 'expired-forest-refresh-token',
+            });
+            mockServer.post('/oauth/token', { error: 'invalid_grant' }, 400);
+            global.fetch = mockServer.fetch;
+            const provider = createProvider();
+            await expect(provider.exchangeRefreshToken(mockClient, 'valid-refresh-token')).rejects.toThrow('Failed to refresh token');
+        });
+    });
+    describe('verifyAccessToken', () => {
+        it('should verify and decode a valid access token', async () => {
+            const mockDecoded = {
+                id: 123,
+                email: 'user@example.com',
+                renderingId: 456,
+                serverToken: 'forest-server-token',
+                exp: Math.floor(Date.now() / 1000) + 3600,
+                iat: Math.floor(Date.now() / 1000),
+            };
+            jsonwebtoken_1.default.verify.mockReturnValue(mockDecoded);
+            const provider = createProvider();
+            const result = await provider.verifyAccessToken('valid-access-token');
+            expect(result.token).toBe('valid-access-token');
+            expect(result.clientId).toBe('123');
+            expect(result.expiresAt).toBe(mockDecoded.exp);
+            expect(result.scopes).toEqual(['mcp:read', 'mcp:write', 'mcp:action']);
+            expect(result.extra).toEqual({
+                userId: 123,
+                email: 'user@example.com',
+                renderingId: 456,
+                environmentApiEndpoint: undefined,
+                forestServerToken: 'forest-server-token',
+            });
+        });
+        it('should throw error for expired access token', async () => {
+            jsonwebtoken_1.default.verify.mockImplementation(() => {
+                throw new jsonwebtoken_1.default.TokenExpiredError('jwt expired', new Date());
+            });
+            const provider = createProvider();
+            await expect(provider.verifyAccessToken('expired-token')).rejects.toThrow('Access token has expired');
+        });
+        it('should throw error for invalid access token', async () => {
+            jsonwebtoken_1.default.verify.mockImplementation(() => {
+                throw new jsonwebtoken_1.default.JsonWebTokenError('invalid signature');
+            });
+            const provider = createProvider();
+            await expect(provider.verifyAccessToken('invalid-token')).rejects.toThrow('Invalid access token');
+        });
+        it('should throw error when using refresh token as access token', async () => {
+            jsonwebtoken_1.default.verify.mockReturnValue({
+                type: 'refresh',
+                clientId: 'test-client-id',
+            });
+            const provider = createProvider();
+            await expect(provider.verifyAccessToken('refresh-token')).rejects.toThrow('Cannot use refresh token as access token');
+        });
+        it('should include environmentApiEndpoint after initialize is called', async () => {
+            mockServer.get('/liana/environment', {
+                data: {
+                    id: '12345',
+                    attributes: { api_endpoint: 'https://api.example.com' },
+                },
+            });
+            global.fetch = mockServer.fetch;
+            const mockDecoded = {
+                id: 123,
+                email: 'user@example.com',
+                renderingId: 456,
+                serverToken: 'forest-server-token',
+                exp: Math.floor(Date.now() / 1000) + 3600,
+                iat: Math.floor(Date.now() / 1000),
+            };
+            jsonwebtoken_1.default.verify.mockReturnValue(mockDecoded);
+            const provider = createProvider();
+            // Call initialize to fetch environment data
+            await provider.initialize();
+            const result = await provider.verifyAccessToken('valid-access-token');
+            expect(result.extra).toEqual({
+                userId: 123,
+                email: 'user@example.com',
+                renderingId: 456,
+                environmentApiEndpoint: 'https://api.example.com',
+                forestServerToken: 'forest-server-token',
+            });
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"forest-oauth-provider.test.js","sourceRoot":"","sources":["../src/forest-oauth-provider.test.ts"],"names":[],"mappings":"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"}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { default as ForestMCPServer } from './server';
+export type { ForestMCPServerOptions, HttpCallback } from './server';
+export { MCP_PATHS, isMcpRoute } from './mcp-paths';
+//# sourceMappingURL=index.d.ts.map