@forestadmin/mcp-server 0.1.0

package/README.md

@@ -0,0 +1,128 @@
+# @forestadmin/mcp-server
+
+Model Context Protocol (MCP) server for Forest Admin with OAuth authentication support.
+
+## Overview
+
+This MCP server provides HTTP REST API access to Forest Admin operations, enabling AI assistants and other MCP clients to interact with your Forest Admin data through a standardized protocol.
+
+## Usage
+
+### With Forest Admin Agent
+
+The MCP server is included with the Forest Admin agent. Simply call `mountAiMcpServer()`:
+
+```typescript
+import { createAgent } from '@forestadmin/agent';
+
+const agent = createAgent(options)
+  .addDataSource(myDataSource)
+  .mountAiMcpServer();
+
+agent.mountOnExpress(app);
+agent.start();
+```
+
+The MCP server will be automatically initialized and mounted on your application.
+
+### Standalone Server
+
+You can also run the MCP server standalone using the CLI:
+
+```bash
+npx forest-mcp-server
+```
+
+Or programmatically:
+
+```bash
+node dist/index.js
+```
+
+### Environment Variables
+
+The following environment variables are required to run the server:
+
+| Variable | Required | Default | Description |
+|----------|----------|---------|-------------|
+| `FOREST_ENV_SECRET` | **Yes** | - | Your Forest Admin environment secret |
+| `FOREST_AUTH_SECRET` | **Yes** | - | Your Forest Admin authentication secret (must match your agent) |
+| `MCP_SERVER_PORT` | No | `3931` | Port for the HTTP server |
+
+### Example Configuration
+
+```bash
+export FOREST_ENV_SECRET="your-env-secret"
+export FOREST_AUTH_SECRET="your-auth-secret"
+export MCP_SERVER_PORT=3931
+
+npx forest-mcp-server
+```
+
+## API Endpoint
+
+Once running, the MCP server exposes a single endpoint:
+
+- **POST** `/mcp` - Main MCP protocol endpoint
+
+The server expects MCP protocol messages in the request body and returns MCP-formatted responses.
+
+## Features
+
+- **HTTP Transport**: Uses streamable HTTP transport for MCP communication
+- **OAuth Authentication**: Built-in support for Forest Admin OAuth
+- **CORS Enabled**: Allows cross-origin requests
+- **Express-based**: Built on top of Express.js for reliability and extensibility
+
+## Development
+
+### Building
+
+```bash
+npm run build
+```
+
+### Watch Mode
+
+```bash
+npm run build:watch
+```
+
+### Linting
+
+```bash
+npm run lint
+```
+
+### Testing
+
+```bash
+npm test
+```
+
+### Cleaning
+
+```bash
+npm run clean
+```
+
+## Architecture
+
+The server consists of:
+
+- **ForestMCPServer**: Main server class managing the MCP server lifecycle
+- **McpServer**: Core MCP protocol implementation
+- **StreamableHTTPServerTransport**: HTTP transport layer for MCP
+- **Express App**: HTTP server handling incoming requests
+
+## License
+
+GPL-3.0
+
+## Repository
+
+[https://github.com/ForestAdmin/agent-nodejs](https://github.com/ForestAdmin/agent-nodejs)
+
+## Support
+
+For issues and feature requests, please visit the [GitHub repository](https://github.com/ForestAdmin/agent-nodejs/tree/main/packages/mcp-server).

package/dist/__mocks__/version.d.ts

@@ -0,0 +1,3 @@
+export declare const VERSION = "0.1.0";
+export declare const NAME = "@forestadmin/mcp-server";
+//# sourceMappingURL=version.d.ts.map

package/dist/__mocks__/version.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NAME = exports.VERSION = void 0;
+// Mock version module for Jest (avoids import.meta.url issues in CommonJS)
+exports.VERSION = '0.1.0';
+exports.NAME = '@forestadmin/mcp-server';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmVyc2lvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9fX21vY2tzX18vdmVyc2lvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSwyRUFBMkU7QUFDOUQsUUFBQSxPQUFPLEdBQUcsT0FBTyxDQUFDO0FBQ2xCLFFBQUEsSUFBSSxHQUFHLHlCQUF5QixDQUFDIn0=

package/dist/cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/dist/cli.js

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const server_1 = __importDefault(require("./server"));
+// Start the server when run directly as CLI
+const server = new server_1.default();
+server.run().catch(error => {
+    console.error('[FATAL] Server crashed:', error);
+    process.exit(1);
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xpLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL2NsaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7QUFFQSxzREFBdUM7QUFFdkMsNENBQTRDO0FBQzVDLE1BQU0sTUFBTSxHQUFHLElBQUksZ0JBQWUsRUFBRSxDQUFDO0FBRXJDLE1BQU0sQ0FBQyxHQUFHLEVBQUUsQ0FBQyxLQUFLLENBQUMsS0FBSyxDQUFDLEVBQUU7SUFDekIsT0FBTyxDQUFDLEtBQUssQ0FBQyx5QkFBeUIsRUFBRSxLQUFLLENBQUMsQ0FBQztJQUNoRCxPQUFPLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQyxDQUFDO0FBQ2xCLENBQUMsQ0FBQyxDQUFDIn0=

package/dist/factory.d.ts

@@ -0,0 +1,51 @@
+import type { HttpCallback } from './server';
+import { Logger } from './server';
+/**
+ * Context passed from the Forest Admin agent to the MCP factory.
+ */
+export interface McpFactoryContext {
+    /** Forest Admin server URL */
+    forestServerUrl: string;
+    /** Environment secret */
+    envSecret: string;
+    /** Authentication secret */
+    authSecret: string;
+    /** Logger function */
+    logger: Logger;
+}
+/**
+ * Options for the MCP factory function.
+ */
+export interface McpFactoryOptions {
+    /**
+     * Optional override for the base URL where the agent is publicly accessible.
+     * If not provided, it will be automatically fetched from Forest Admin API
+     * (the environment's api_endpoint configuration).
+     * Example: 'https://my-app.example.com' or 'http://localhost:3000'
+     */
+    baseUrl?: string;
+}
+/**
+ * Factory function to create an MCP HTTP callback for use with the Forest Admin agent.
+ *
+ * This function is designed to be used with the `agent.useMcp()` method:
+ *
+ * @example
+ * ```typescript
+ * import { createAgent } from '@forestadmin/agent';
+ * import { createMcpServer } from '@forestadmin/mcp-server';
+ *
+ * const agent = createAgent(options)
+ *   .addDataSource(myDataSource)
+ *   .useMcp(createMcpServer, { baseUrl: 'https://my-app.example.com' });
+ *
+ * agent.mountOnExpress(app);
+ * agent.start();
+ * ```
+ *
+ * @param context - Context containing Forest Admin configuration (provided by the agent)
+ * @param options - Optional configuration for the MCP server
+ * @returns An HTTP callback that handles MCP routes
+ */
+export declare function createMcpServer(context: McpFactoryContext, options?: McpFactoryOptions): Promise<HttpCallback>;
+//# sourceMappingURL=factory.d.ts.map

package/dist/factory.js

@@ -0,0 +1,40 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMcpServer = createMcpServer;
+const server_1 = __importDefault(require("./server"));
+/**
+ * Factory function to create an MCP HTTP callback for use with the Forest Admin agent.
+ *
+ * This function is designed to be used with the `agent.useMcp()` method:
+ *
+ * @example
+ * ```typescript
+ * import { createAgent } from '@forestadmin/agent';
+ * import { createMcpServer } from '@forestadmin/mcp-server';
+ *
+ * const agent = createAgent(options)
+ *   .addDataSource(myDataSource)
+ *   .useMcp(createMcpServer, { baseUrl: 'https://my-app.example.com' });
+ *
+ * agent.mountOnExpress(app);
+ * agent.start();
+ * ```
+ *
+ * @param context - Context containing Forest Admin configuration (provided by the agent)
+ * @param options - Optional configuration for the MCP server
+ * @returns An HTTP callback that handles MCP routes
+ */
+async function createMcpServer(context, options) {
+    const mcpServer = new server_1.default({
+        forestServerUrl: context.forestServerUrl,
+        envSecret: context.envSecret,
+        authSecret: context.authSecret,
+        logger: context.logger,
+    });
+    const baseUrl = options?.baseUrl ? new URL('/', options.baseUrl) : undefined;
+    return mcpServer.getHttpCallback(baseUrl);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmFjdG9yeS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy9mYWN0b3J5LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7O0FBcURBLDBDQWNDO0FBakVELHNEQUFtRDtBQTZCbkQ7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztHQXFCRztBQUNJLEtBQUssVUFBVSxlQUFlLENBQ25DLE9BQTBCLEVBQzFCLE9BQTJCO0lBRTNCLE1BQU0sU0FBUyxHQUFHLElBQUksZ0JBQWUsQ0FBQztRQUNwQyxlQUFlLEVBQUUsT0FBTyxDQUFDLGVBQWU7UUFDeEMsU0FBUyxFQUFFLE9BQU8sQ0FBQyxTQUFTO1FBQzVCLFVBQVUsRUFBRSxPQUFPLENBQUMsVUFBVTtRQUM5QixNQUFNLEVBQUUsT0FBTyxDQUFDLE1BQU07S0FDdkIsQ0FBQyxDQUFDO0lBRUgsTUFBTSxPQUFPLEdBQUcsT0FBTyxFQUFFLE9BQU8sQ0FBQyxDQUFDLENBQUMsSUFBSSxHQUFHLENBQUMsR0FBRyxFQUFFLE9BQU8sQ0FBQyxPQUFPLENBQUMsQ0FBQyxDQUFDLENBQUMsU0FBUyxDQUFDO0lBRTdFLE9BQU8sU0FBUyxDQUFDLGVBQWUsQ0FBQyxPQUFPLENBQUMsQ0FBQztBQUM1QyxDQUFDIn0=

package/dist/forest-oauth-provider.d.ts

@@ -0,0 +1,44 @@
+import type { Logger } from './server';
+import type { OAuthRegisteredClientsStore } from '@modelcontextprotocol/sdk/server/auth/clients.js';
+import type { AuthorizationParams, OAuthServerProvider } from '@modelcontextprotocol/sdk/server/auth/provider.js';
+import type { AuthInfo } from '@modelcontextprotocol/sdk/server/auth/types.js';
+import type { OAuthClientInformationFull, OAuthTokenRevocationRequest, OAuthTokens } from '@modelcontextprotocol/sdk/shared/auth.js';
+import type { Response } from 'express';
+export interface ForestOAuthProviderOptions {
+    forestServerUrl: string;
+    forestAppUrl: string;
+    envSecret: string;
+    authSecret: string;
+    logger: Logger;
+}
+/**
+ * OAuth Server Provider that integrates with Forest Admin authentication
+ */
+export default class ForestOAuthProvider implements OAuthServerProvider {
+    private forestServerUrl;
+    private forestAppUrl;
+    private envSecret;
+    private authSecret;
+    private forestClient;
+    private environmentId?;
+    private environmentApiEndpoint?;
+    private logger;
+    constructor({ forestServerUrl, forestAppUrl, envSecret, authSecret, logger, }: ForestOAuthProviderOptions);
+    initialize(): Promise<void>;
+    private fetchEnvironmentId;
+    /**
+     * Get the base URL for the MCP server from the environment's api_endpoint.
+     * Returns undefined if the environment info hasn't been fetched yet.
+     */
+    getBaseUrl(): URL | undefined;
+    get clientsStore(): OAuthRegisteredClientsStore;
+    authorize(client: OAuthClientInformationFull, params: AuthorizationParams, res: Response): Promise<void>;
+    challengeForAuthorizationCode(client: OAuthClientInformationFull, authorizationCode: string): Promise<string>;
+    exchangeAuthorizationCode(client: OAuthClientInformationFull, authorizationCode: string, codeVerifier?: string, redirectUri?: string): Promise<OAuthTokens>;
+    exchangeRefreshToken(client: OAuthClientInformationFull, refreshToken: string, scopes?: string[]): Promise<OAuthTokens>;
+    private generateAccessToken;
+    verifyAccessToken(token: string): Promise<AuthInfo>;
+    revokeToken(_client: OAuthClientInformationFull, _request: OAuthTokenRevocationRequest): Promise<void>;
+    skipLocalPkceValidation: boolean;
+}
+//# sourceMappingURL=forest-oauth-provider.d.ts.map

package/dist/forest-oauth-provider.js

@@ -0,0 +1,253 @@
+"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 errors_js_1 = require("@modelcontextprotocol/sdk/server/auth/errors.js");
+const jsonwebtoken_1 = __importDefault(require("jsonwebtoken"));
+/**
+ * OAuth Server Provider that integrates with Forest Admin authentication
+ */
+class ForestOAuthProvider {
+    constructor({ forestServerUrl, forestAppUrl, envSecret, authSecret, logger, }) {
+        // Skip PKCE validation to match original implementation
+        this.skipLocalPkceValidation = true;
+        this.forestServerUrl = forestServerUrl;
+        this.forestAppUrl = forestAppUrl;
+        this.envSecret = envSecret;
+        this.authSecret = authSecret;
+        this.logger = logger;
+        this.forestClient = (0, forestadmin_client_1.default)({
+            forestServerUrl: this.forestServerUrl,
+            envSecret: this.envSecret,
+        });
+    }
+    async initialize() {
+        try {
+            await this.fetchEnvironmentId();
+        }
+        catch (error) {
+            // Log warning but don't throw - the MCP server can still partially function
+            // The authorize method will return an appropriate error when environmentId is missing
+            this.logger('Warn', `Failed to fetch environmentId from Forest Admin API: ${error}`);
+        }
+    }
+    async fetchEnvironmentId() {
+        if (!this.envSecret) {
+            throw new Error('FOREST_ENV_SECRET is required to fetch environment ID');
+        }
+        // Call Forest Admin API to get environment information
+        const response = await fetch(`${this.forestServerUrl}/liana/environment`, {
+            method: 'GET',
+            headers: {
+                'forest-secret-key': this.envSecret,
+                'Content-Type': 'application/json',
+            },
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`Failed to fetch environment from Forest Admin API: ${response.status} ${response.statusText}. ${errorText}`);
+        }
+        const data = (await response.json());
+        this.environmentId = parseInt(data.data.id, 10);
+        this.environmentApiEndpoint = data.data.attributes.api_endpoint;
+    }
+    /**
+     * Get the base URL for the MCP server from the environment's api_endpoint.
+     * Returns undefined if the environment info hasn't been fetched yet.
+     */
+    getBaseUrl() {
+        if (!this.environmentApiEndpoint) {
+            return undefined;
+        }
+        return new URL(this.environmentApiEndpoint);
+    }
+    get clientsStore() {
+        return {
+            getClient: async (clientId) => {
+                // Call Forest Admin API to get client information
+                const response = await fetch(`${this.forestServerUrl}/oauth/register/${clientId}`, {
+                    method: 'GET',
+                    headers: {
+                        'Content-Type': 'application/json',
+                    },
+                });
+                // Log and return undefined for other errors (don't expose internal errors)
+                if (!response.ok) {
+                    console.error(`[ForestOAuthProvider] Failed to fetch client ${clientId}: ${response.status} ${response.statusText}`);
+                    return undefined;
+                }
+                // Return registered client if exists
+                return response.json();
+            },
+        };
+    }
+    async authorize(client, params, res) {
+        try {
+            // Ensure environmentId is available
+            if (!this.environmentId) {
+                throw new Error('Environment ID not available. Make sure initialize() was called and the Forest Admin API is reachable.');
+            }
+            // Redirect to Forest Admin agent for actual authentication
+            const agentAuthUrl = new URL('/oauth/authorize', this.forestAppUrl);
+            agentAuthUrl.searchParams.set('redirect_uri', params.redirectUri);
+            agentAuthUrl.searchParams.set('code_challenge', params.codeChallenge);
+            agentAuthUrl.searchParams.set('code_challenge_method', 'S256');
+            agentAuthUrl.searchParams.set('response_type', 'code');
+            agentAuthUrl.searchParams.set('client_id', client.client_id);
+            agentAuthUrl.searchParams.set('state', params.state);
+            agentAuthUrl.searchParams.set('scope', params.scopes.join('+'));
+            if (params.resource?.href) {
+                agentAuthUrl.searchParams.set('resource', params.resource.href);
+            }
+            agentAuthUrl.searchParams.set('environmentId', this.environmentId.toString());
+            res.redirect(agentAuthUrl.toString());
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            this.logger('Error', `[ForestOAuthProvider] Authorization error:: ${errorMessage}`);
+            // Don't expose internal error details to the client - use a generic message
+            // The actual error is logged above for debugging
+            res.redirect(`${params.redirectUri}?error=server_error&error_description=${encodeURIComponent('Authorization failed. Please try again or contact support.')}`);
+        }
+    }
+    async challengeForAuthorizationCode(client, authorizationCode) {
+        // This is never called but required by TS !
+        return authorizationCode;
+    }
+    async exchangeAuthorizationCode(client, authorizationCode, codeVerifier, redirectUri) {
+        try {
+            return await this.generateAccessToken(client, {
+                grant_type: 'authorization_code',
+                code: authorizationCode,
+                redirect_uri: redirectUri,
+                client_id: client.client_id,
+                code_verifier: codeVerifier,
+            });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            throw new errors_js_1.InvalidRequestError(`Failed to exchange authorization code: ${message}`);
+        }
+    }
+    async exchangeRefreshToken(client, refreshToken, scopes) {
+        // Verify and decode the refresh token
+        let decoded;
+        try {
+            decoded = jsonwebtoken_1.default.verify(refreshToken, this.authSecret);
+        }
+        catch (error) {
+            throw new errors_js_1.InvalidTokenError('Invalid or expired refresh token');
+        }
+        // Validate token type
+        if (decoded.type !== 'refresh') {
+            throw new errors_js_1.UnsupportedTokenTypeError('Invalid token type');
+        }
+        // Validate client_id matches
+        if (decoded.clientId !== client.client_id) {
+            throw new errors_js_1.InvalidClientError('Token was not issued to this client');
+        }
+        // Exchange the Forest refresh token for new tokens
+        try {
+            return await this.generateAccessToken(client, {
+                grant_type: 'refresh_token',
+                refresh_token: decoded.serverRefreshToken,
+                client_id: client.client_id,
+                scopes,
+            });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            throw new errors_js_1.InvalidRequestError(`Failed to refresh token: ${message}`);
+        }
+    }
+    async generateAccessToken(client, tokenPayload) {
+        const response = await fetch(`${this.forestServerUrl}/oauth/token`, {
+            method: 'POST',
+            headers: {
+                'forest-secret-key': this.envSecret,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify(tokenPayload),
+        });
+        if (!response.ok) {
+            const errorBody = await response.json();
+            throw new errors_js_1.CustomOAuthError(errorBody.error || 'server_error', errorBody.error_description || 'Failed to exchange authorization code');
+        }
+        const { access_token: forestServerAccessToken, refresh_token: forestServerRefreshToken } = (await response.json());
+        // Get updated user info
+        const decodedAccessToken = jsonwebtoken_1.default.decode(forestServerAccessToken);
+        if (!decodedAccessToken) {
+            throw new Error('Failed to decode access token from Forest Admin server');
+        }
+        const { meta: { renderingId }, exp: expirationDate, scope, } = decodedAccessToken;
+        const decodedRefreshToken = jsonwebtoken_1.default.decode(forestServerRefreshToken);
+        if (!decodedRefreshToken) {
+            throw new Error('Failed to decode refresh token from Forest Admin server');
+        }
+        const { exp: refreshTokenExpirationDate } = decodedRefreshToken;
+        const user = await this.forestClient.authService.getUserInfo(renderingId, forestServerAccessToken);
+        // Create new access token
+        const expiresIn = expirationDate - Math.floor(Date.now() / 1000);
+        const tokenScopes = scope ? scope.split(' ') : ['mcp:read', 'mcp:write', 'mcp:action'];
+        const accessToken = jsonwebtoken_1.default.sign({ ...user, serverToken: forestServerAccessToken, scopes: tokenScopes }, this.authSecret, { expiresIn });
+        // Create new refresh token (token rotation for security)
+        const refreshToken = jsonwebtoken_1.default.sign({
+            type: 'refresh',
+            clientId: client.client_id,
+            userId: user.id,
+            renderingId,
+            serverRefreshToken: forestServerRefreshToken,
+        }, this.authSecret, { expiresIn: refreshTokenExpirationDate - Math.floor(Date.now() / 1000) });
+        return {
+            access_token: accessToken,
+            token_type: 'Bearer',
+            expires_in: expiresIn > 0 ? expiresIn : 3600,
+            refresh_token: refreshToken,
+            scope: scope || client.scope,
+        };
+    }
+    async verifyAccessToken(token) {
+        try {
+            const decoded = jsonwebtoken_1.default.verify(token, this.authSecret);
+            // Ensure this is an access token (not a refresh token)
+            if ('type' in decoded && decoded.type === 'refresh') {
+                throw new errors_js_1.UnsupportedTokenTypeError('Cannot use refresh token as access token');
+            }
+            // Use scopes from token if available, otherwise fall back to defaults
+            const scopes = decoded.scopes || ['mcp:read', 'mcp:write', 'mcp:action'];
+            return {
+                token,
+                clientId: decoded.id.toString(),
+                expiresAt: decoded.exp,
+                scopes,
+                extra: {
+                    userId: decoded.id,
+                    email: decoded.email,
+                    renderingId: decoded.renderingId,
+                    environmentApiEndpoint: this.environmentApiEndpoint,
+                    forestServerToken: decoded.serverToken,
+                },
+            };
+        }
+        catch (error) {
+            this.logger('Error', `Error verifying token: ${error}`);
+            if (error instanceof jsonwebtoken_1.default.TokenExpiredError) {
+                throw new errors_js_1.InvalidTokenError('Access token has expired');
+            }
+            if (error instanceof jsonwebtoken_1.default.JsonWebTokenError) {
+                throw new errors_js_1.InvalidTokenError('Invalid access token');
+            }
+            throw error;
+        }
+    }
+    async revokeToken(_client, _request) {
+        // Token revocation is not currently implemented.
+        // Per RFC 7009, the revocation endpoint should return success even if the token
+        // is already invalid or unknown, so we silently succeed here.
+        // TODO: Implement actual token revocation with Forest Admin server when supported.
+    }
+}
+exports.default = ForestOAuthProvider;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"forest-oauth-provider.js","sourceRoot":"","sources":["../src/forest-oauth-provider.ts"],"names":[],"mappings":"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"}

package/dist/forest-oauth-provider.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=forest-oauth-provider.test.d.ts.map