@payloadcms/figma 0.0.1-alpha.5 → 0.0.1-alpha.51

package/dist/api/control-plane.d.ts

@@ -44,8 +44,8 @@ export interface CreateDeploymentResponse {
 export interface CreateDeploymentApiResponse {
     error: boolean;
     meta: {
-        code_upload_url: string;
         deployment_id: string;
+        lambda_zip_upload_url: string;
         static_asset_upload_urls: Record<string, string>;
     };
     status: number;
@@ -65,6 +65,8 @@ export interface PerformDeploymentResponse {
     deploymentId: string;
     /** Status message */
     message: string;
+    /** List of tenant domains */
+    tenantDomains: string[];
 }
 export interface PerformDeploymentApiResponse {
     error: boolean;
@@ -72,6 +74,7 @@ export interface PerformDeploymentApiResponse {
         deployment_id: string;
         message: string;
         status: string;
+        tenant_domains: string[];
     };
     status: number;
 }
@@ -121,4 +124,31 @@ export declare function createDeployment(accessToken: string, tenantId: string,
  * @returns Deployment status and message
  */
 export declare function performDeployment(accessToken: string, tenantId: string, options: PerformDeploymentOptions): Promise<PerformDeploymentResponse>;
+/**
+ * A single environment returned by the bootstrap endpoint
+ */
+export type BootstrapEnvironment = {
+    contentSystemId: string;
+    name: string;
+    tenantInstanceId: string;
+};
+/**
+ * Response from the bootstrap endpoint (camelCased)
+ */
+export type BootstrapInfo = {
+    environments: BootstrapEnvironment[];
+    oauthCredentials: {
+        oauthClientId: string;
+        oauthClientSecret: string;
+    };
+};
+/**
+ * Get bootstrap info for a CMS resource
+ * Maps to: GET /v1/cms/:cmsResourceId/bootstrap
+ *
+ * @param accessToken - OAuth access token
+ * @param cmsResourceId - CMS Resource ID (project ID)
+ * @param environmentName - Optional environment name filter
+ */
+export declare function getBootstrapInfo(accessToken: string, cmsResourceId: string, environmentName?: string): Promise<BootstrapInfo>;
 //# sourceMappingURL=control-plane.d.ts.map

package/dist/api/control-plane.js

@@ -2,18 +2,12 @@
  * Control Plane API Client
  *
  * TODO: Replace with real API calls when Control Plane is available
- */ import { getEnvironment } from '../constants.js';
+ */ import { getEnvConfig } from '../constants.js';
 import * as log from '../utils/log.js';
-/**
- * Control Plane API base URLs
- */ const CONTROL_PLANE_API_URLS = {
-    production: 'https://api.figma.com',
-    staging: 'https://api.staging.figma.com'
-};
 /**
  * Get the Control Plane API base URL based on environment
  */ function getControlPlaneBaseUrl() {
-    return process.env.FIGMA_API_BASE_URL || CONTROL_PLANE_API_URLS[getEnvironment()];
+    return process.env.FIGMA_API_BASE_URL || getEnvConfig().apiBaseUrl;
 }
 /**
  * Error thrown when Control Plane API calls fail
@@ -32,9 +26,7 @@ import * as log from '../utils/log.js';
  * @param accessToken - OAuth access token
  * @returns Array of tenant instances
  */ export async function listTenants(accessToken) {
-    // Check if control plane API should be mocked
-    // Default to true until real API is available
-    const shouldMock = process.env.FIGMA_MOCK_CONTROL_PLANE !== 'false';
+    const shouldMock = process.env.FIGMA_MOCK_CONTROL_PLANE === 'true';
     if (shouldMock) {
         // MOCK IMPLEMENTATION: Return sample tenants for testing
         log.debug('Using mock Control Plane API for listTenants (FIGMA_MOCK_CONTROL_PLANE != "false")');
@@ -58,14 +50,15 @@ import * as log from '../utils/log.js';
         ];
     }
     // REAL API IMPLEMENTATION
-    const response = await fetch(`${getControlPlaneBaseUrl()}/v1/tenant`, {
-        headers: {
-            Authorization: `Bearer ${accessToken}`
-        }
+    const response = await controlPlaneFetch({
+        context: 'list tenants',
+        options: {
+            headers: {
+                Authorization: `Bearer ${accessToken}`
+            }
+        },
+        url: `${getControlPlaneBaseUrl()}/v1/tenant`
     });
-    if (!response.ok) {
-        throw new ControlPlaneError(`Failed to list tenants: ${response.status} ${response.statusText}`, response.status);
-    }
     return response.json();
 }
 /**
@@ -77,7 +70,7 @@ import * as log from '../utils/log.js';
  * @returns Newly created tenant
  */ export async function createTenant(accessToken, options) {
     // Check if control plane API should be mocked
-    const shouldMock = process.env.FIGMA_MOCK_CONTROL_PLANE !== 'false';
+    const shouldMock = process.env.FIGMA_MOCK_CONTROL_PLANE === 'true';
     if (shouldMock) {
         // MOCK IMPLEMENTATION: Generate mock tenant for testing
         log.debug('Using mock Control Plane API for createTenant (FIGMA_MOCK_CONTROL_PLANE != "false")');
@@ -94,19 +87,20 @@ import * as log from '../utils/log.js';
         };
     }
     // REAL API IMPLEMENTATION
-    const response = await fetch(`${getControlPlaneBaseUrl()}/v1/tenant`, {
-        body: JSON.stringify({
-            name: options.name
-        }),
-        headers: {
-            Authorization: `Bearer ${accessToken}`,
-            'Content-Type': 'application/json'
+    const response = await controlPlaneFetch({
+        context: 'create tenant',
+        options: {
+            body: JSON.stringify({
+                name: options.name
+            }),
+            headers: {
+                Authorization: `Bearer ${accessToken}`,
+                'Content-Type': 'application/json'
+            },
+            method: 'POST'
         },
-        method: 'POST'
+        url: `${getControlPlaneBaseUrl()}/v1/tenant`
     });
-    if (!response.ok) {
-        throw new ControlPlaneError(`Failed to create tenant: ${response.status} ${response.statusText}`, response.status);
-    }
     return response.json();
 }
 /**
@@ -118,7 +112,7 @@ import * as log from '../utils/log.js';
  * @returns Tenant details
  */ export async function getTenantDetails(accessToken, tenantId) {
     // Check if control plane API should be mocked
-    const shouldMock = process.env.FIGMA_MOCK_CONTROL_PLANE !== 'false';
+    const shouldMock = process.env.FIGMA_MOCK_CONTROL_PLANE === 'true';
     if (shouldMock) {
         // MOCK IMPLEMENTATION: Return mock tenant details for testing
         log.debug('Using mock Control Plane API for getTenantDetails (FIGMA_MOCK_CONTROL_PLANE != "false")');
@@ -132,14 +126,15 @@ import * as log from '../utils/log.js';
         };
     }
     // REAL API IMPLEMENTATION
-    const response = await fetch(`${getControlPlaneBaseUrl()}/v1/tenant/${tenantId}`, {
-        headers: {
-            Authorization: `Bearer ${accessToken}`
-        }
+    const response = await controlPlaneFetch({
+        context: 'get tenant details',
+        options: {
+            headers: {
+                Authorization: `Bearer ${accessToken}`
+            }
+        },
+        url: `${getControlPlaneBaseUrl()}/v1/tenant/${tenantId}`
     });
-    if (!response.ok) {
-        throw new ControlPlaneError(`Failed to get tenant details: ${response.status} ${response.statusText}`, response.status);
-    }
     return response.json();
 }
 /**
@@ -152,10 +147,10 @@ import * as log from '../utils/log.js';
  * @returns Deployment ID and upload URLs
  */ export async function createDeployment(accessToken, tenantId, options) {
     // Check if control plane API should be mocked
-    const shouldMock = process.env.FIGMA_MOCK_CONTROL_PLANE !== 'false';
+    const shouldMock = process.env.FIGMA_MOCK_CONTROL_PLANE === 'true';
     if (shouldMock) {
         // MOCK IMPLEMENTATION: Generate mock deployment and signed URLs
-        log.debug('Using mock Control Plane API for createDeployment (FIGMA_MOCK_CONTROL_PLANE != "false")');
+        log.debug('Using mock Control Plane API for createDeployment (FIGMA_MOCK_CONTROL_PLANE === "true")');
         const deploymentId = `deploy_${Math.random().toString(36).substring(2, 11)}`;
         const mockBucket = 'figma-cms-deployments-mock';
         const mockRegion = 'us-west-2';
@@ -174,24 +169,27 @@ import * as log from '../utils/log.js';
             staticAssetUploadUrls
         };
     }
+    const url = `${getControlPlaneBaseUrl()}/v1/cms/tenant/${tenantId}/deploy/create`;
+    log.debug(`Calling createDeployment API at ${url}`);
     // REAL API IMPLEMENTATION
-    const response = await fetch(`${getControlPlaneBaseUrl()}/v1/tenant/${tenantId}/deploy/create`, {
-        body: JSON.stringify({
-            static_assets: options.staticAssets
-        }),
-        headers: {
-            Authorization: `Bearer ${accessToken}`,
-            'Content-Type': 'application/json'
+    const response = await controlPlaneFetch({
+        context: 'create deployment',
+        options: {
+            body: JSON.stringify({
+                static_assets: options.staticAssets
+            }),
+            headers: {
+                Authorization: `Bearer ${accessToken}`,
+                'Content-Type': 'application/json'
+            },
+            method: 'POST'
         },
-        method: 'POST'
+        url
     });
-    if (!response.ok) {
-        throw new ControlPlaneError(`Failed to create deployment: ${response.status} ${response.statusText}`, response.status);
-    }
     const data = await response.json();
     // Map API response format to our interface
     return {
-        codeUploadUrl: data.meta.code_upload_url,
+        codeUploadUrl: data.meta.lambda_zip_upload_url,
         deploymentId: data.meta.deployment_id,
         staticAssetUploadUrls: data.meta.static_asset_upload_urls
     };
@@ -205,36 +203,108 @@ import * as log from '../utils/log.js';
  * @param options - Deployment perform options
  * @returns Deployment status and message
  */ export async function performDeployment(accessToken, tenantId, options) {
-    // Check if control plane API should be mocked
-    const shouldMock = process.env.FIGMA_MOCK_CONTROL_PLANE !== 'false';
+    const shouldMock = process.env.FIGMA_MOCK_CONTROL_PLANE === 'true';
     if (shouldMock) {
         // MOCK IMPLEMENTATION: Return mock deployment status
         log.debug('Using mock Control Plane API for performDeployment (FIGMA_MOCK_CONTROL_PLANE != "false")');
         return {
             deploymentId: options.deploymentId,
-            message: 'Deployment initiated successfully'
+            message: 'Deployment initiated successfully',
+            tenantDomains: [
+                'example.figmasource.site'
+            ]
         };
     }
+    const url = `${getControlPlaneBaseUrl()}/v1/cms/tenant/${tenantId}/deploy/perform`;
+    log.debug(`Calling performDeployment API at ${url}`);
     // REAL API IMPLEMENTATION
-    const response = await fetch(`${getControlPlaneBaseUrl()}/v1/tenant/${tenantId}/deploy/perform`, {
-        body: JSON.stringify({
-            deployment_id: options.deploymentId
-        }),
-        headers: {
-            Authorization: `Bearer ${accessToken}`,
-            'Content-Type': 'application/json'
+    const response = await controlPlaneFetch({
+        context: 'perform deployment',
+        options: {
+            body: JSON.stringify({
+                deployment_id: options.deploymentId
+            }),
+            headers: {
+                Authorization: `Bearer ${accessToken}`,
+                'Content-Type': 'application/json'
+            },
+            method: 'POST'
         },
-        method: 'POST'
+        url
     });
-    if (!response.ok) {
-        throw new ControlPlaneError(`Failed to perform deployment: ${response.status} ${response.statusText}`, response.status);
-    }
     const data = await response.json();
     // Map API response to our interface
     return {
         deploymentId: data.meta.deployment_id,
-        message: data.meta.message || 'Deployment initiated'
+        message: data.meta.message || 'Deployment initiated',
+        tenantDomains: data.meta.tenant_domains
     };
 }
+/**
+ * Get bootstrap info for a CMS resource
+ * Maps to: GET /v1/cms/:cmsResourceId/bootstrap
+ *
+ * @param accessToken - OAuth access token
+ * @param cmsResourceId - CMS Resource ID (project ID)
+ * @param environmentName - Optional environment name filter
+ */ export async function getBootstrapInfo(accessToken, cmsResourceId, environmentName) {
+    const baseUrl = getControlPlaneBaseUrl();
+    let url = `${baseUrl}/v1/cms/${cmsResourceId}/bootstrap`;
+    if (environmentName) {
+        url += `?environment_name=${encodeURIComponent(environmentName)}`;
+    }
+    log.debug(`Calling getBootstrapInfo API at ${url}`);
+    const response = await controlPlaneFetch({
+        context: 'get bootstrap info',
+        options: {
+            headers: {
+                Authorization: `Bearer ${accessToken}`
+            }
+        },
+        url
+    });
+    const data = await response.json();
+    return {
+        environments: data.meta.environments.map((env)=>({
+                name: env.name,
+                contentSystemId: env.content_system_id,
+                tenantInstanceId: env.tenant_instance_id
+            })),
+        oauthCredentials: {
+            oauthClientId: data.meta.oauth_credentials.oauth_client_id,
+            oauthClientSecret: data.meta.oauth_credentials.oauth_client_secret
+        }
+    };
+}
+const MAX_RETRIES = 3;
+const INITIAL_RETRY_DELAY = 1000;
+function sleep(ms) {
+    return new Promise((resolve)=>setTimeout(resolve, ms));
+}
+async function controlPlaneFetch(params) {
+    const { context, options, url } = params;
+    let lastError;
+    for(let attempt = 0; attempt < MAX_RETRIES; attempt++){
+        try {
+            const response = await fetch(url, options);
+            if (response.ok) {
+                return response;
+            }
+            if (response.status < 500) {
+                throw new ControlPlaneError(`Failed to ${context}: ${response.status} ${response.statusText}`, response.status);
+            }
+            lastError = new ControlPlaneError(`Failed to ${context}: ${response.status} ${response.statusText}`, response.status);
+        } catch (error) {
+            if (error instanceof ControlPlaneError) {
+                throw error;
+            }
+            lastError = error instanceof Error ? error : new Error('Unknown error');
+        }
+        if (attempt < MAX_RETRIES - 1) {
+            await sleep(INITIAL_RETRY_DELAY * Math.pow(2, attempt));
+        }
+    }
+    throw new ControlPlaneError(`Network error while ${context}: ${lastError?.message || 'Unknown error'}`, undefined, lastError);
+}
 
 //# sourceMappingURL=control-plane.js.map

package/dist/api/figma-api.d.ts

@@ -5,6 +5,15 @@
  * Handles project token generation and other CMS-related API calls
  */
 import type { ProjectToken } from '../auth/types.js';
+/**
+ * User info from Figma API /v1/me endpoint
+ */
+export type FigmaUserInfo = {
+    email: string;
+    handle: string;
+    id: string;
+    img_url: string;
+};
 /**
  * Error thrown when Figma API calls fail
  */
@@ -28,4 +37,15 @@ export declare class FigmaApiError extends Error {
  * @throws {FigmaApiError} If the API call fails
  */
 export declare function getProjectToken(accessToken: string, tenantId: string): Promise<ProjectToken>;
+/**
+ * Get user info from Figma API
+ *
+ * Endpoint: GET https://api.figma.com/v1/me
+ * Requires OAuth access_token (not project token)
+ *
+ * @param accessToken - OAuth access token for authentication
+ * @returns FigmaUserInfo with user profile data
+ * @throws {FigmaApiError} If the API call fails
+ */
+export declare function getUserInfo(accessToken: string): Promise<FigmaUserInfo>;
 //# sourceMappingURL=figma-api.d.ts.map

package/dist/api/figma-api.js

@@ -3,7 +3,8 @@
  *
  * Client for Figma REST API (Pixie) endpoints
  * Handles project token generation and other CMS-related API calls
- */ import * as log from '../utils/log.js';
+ */ import { getEnvConfig } from '../constants.js';
+import * as log from '../utils/log.js';
 /**
  * Error thrown when Figma API calls fail
  */ export class FigmaApiError extends Error {
@@ -14,19 +15,6 @@
         this.name = 'FigmaApiError';
     }
 }
-/**
- * Base URLs for Figma API
- */ const API_BASE_URLS = {
-    prod: 'https://api.figma.com',
-    staging: 'https://api.staging.figma.com'
-};
-/**
- * Get the Figma API base URL based on environment
- * TODO: Use this once real API endpoints are available
- */ function _getApiBaseUrl() {
-    // For now, default to staging to match OAuth config
-    return process.env.FIGMA_API_BASE_URL || API_BASE_URLS.staging;
-}
 /**
  * Get a project token (JWT) for a specific tenant/CMS
  *
@@ -41,13 +29,41 @@
  * @returns ProjectToken with JWT and expiry information
  * @throws {FigmaApiError} If the API call fails
  */ export async function getProjectToken(accessToken, tenantId) {
-    // Check if project token API should be mocked
-    // Default to true until real API is available
-    const shouldMock = process.env.FIGMA_MOCK_PROJECT_TOKEN !== 'false';
+    // Priority 1: Check for direct token value from environment
+    const envTokenValue = process.env.FIGMA_MOCK_PROJECT_TOKEN_VALUE;
+    if (envTokenValue) {
+        log.debug('Using direct project token from FIGMA_MOCK_PROJECT_TOKEN_VALUE');
+        try {
+            // Parse JWT payload to extract claims
+            const parts = envTokenValue.split('.');
+            if (parts.length !== 3) {
+                throw new Error('Invalid JWT format: must have 3 parts (header.payload.signature)');
+            }
+            const payload = parts[1];
+            const base64 = payload.replace(/-/g, '+').replace(/_/g, '/');
+            const paddedBase64 = base64.padEnd(base64.length + (4 - base64.length % 4) % 4, '=');
+            const decodedPayload = JSON.parse(Buffer.from(paddedBase64, 'base64').toString('utf-8'));
+            if (!decodedPayload.exp || typeof decodedPayload.exp !== 'number') {
+                throw new Error('JWT payload missing exp claim');
+            }
+            // Extract tenant ID from aud claim (use parameter as fallback)
+            const extractedTenantId = decodedPayload.aud || tenantId;
+            return {
+                expiresAt: decodedPayload.exp * 1000,
+                tenantId: extractedTenantId,
+                token: envTokenValue
+            };
+        } catch (error) {
+            throw new FigmaApiError(`Invalid JWT token in FIGMA_MOCK_PROJECT_TOKEN_VALUE: ${error instanceof Error ? error.message : 'Unknown error'}`, undefined, error instanceof Error ? error : undefined);
+        }
+    }
+    // Priority 2: Check if project token API should be mocked
+    // Default to false (use real API)
+    const shouldMock = process.env.FIGMA_MOCK_PROJECT_TOKEN === 'true';
     try {
         if (shouldMock) {
             // MOCK IMPLEMENTATION: Generate a mock JWT token for testing
-            log.debug('Using mock project token API for getProjectToken (FIGMA_MOCK_PROJECT_TOKEN != "false")');
+            log.debug('Using mock project token API for getProjectToken (FIGMA_MOCK_PROJECT_TOKEN = "true")');
             const mockToken = createMockJWT(tenantId, 25) // 25 minutes expiry
             ;
             // Mock response data
@@ -68,7 +84,7 @@
             };
         }
         // REAL API IMPLEMENTATION
-        const baseUrl = _getApiBaseUrl();
+        const baseUrl = process.env.FIGMA_API_BASE_URL || getEnvConfig().apiBaseUrl;
         const url = `${baseUrl}/v1/cms/${tenantId}/token/`;
         const response = await fetch(url, {
             headers: {
@@ -81,12 +97,19 @@
             let errorMessage = `Failed to get project token: ${response.status} ${response.statusText}`;
             try {
                 const errorBody = await response.json();
-                if (errorBody.error || errorBody.message) {
-                    errorMessage = errorBody.error || errorBody.message;
+                // Only use string error messages (API may return { error: true })
+                if (typeof errorBody.message === 'string') {
+                    errorMessage = errorBody.message;
+                } else if (typeof errorBody.error === 'string') {
+                    errorMessage = errorBody.error;
                 }
             } catch  {
             // Ignore JSON parse errors for error body
             }
+            // Provide actionable error for common cases
+            if (response.status === 404) {
+                errorMessage = `Content System ID "${tenantId}" not found. Ensure FIGMA_CONTENT_API_CONTENT_SYSTEM_ID is set to a valid content system ID in your .env file.`;
+            }
             throw new FigmaApiError(errorMessage, response.status);
         }
         const data = await response.json();
@@ -165,5 +188,38 @@
         throw new FigmaApiError(`Failed to parse JWT expiry: ${error instanceof Error ? error.message : 'Unknown error'}`, undefined, error instanceof Error ? error : undefined);
     }
 }
+/**
+ * Get user info from Figma API
+ *
+ * Endpoint: GET https://api.figma.com/v1/me
+ * Requires OAuth access_token (not project token)
+ *
+ * @param accessToken - OAuth access token for authentication
+ * @returns FigmaUserInfo with user profile data
+ * @throws {FigmaApiError} If the API call fails
+ */ export async function getUserInfo(accessToken) {
+    const baseUrl = process.env.FIGMA_API_BASE_URL || getEnvConfig().apiBaseUrl;
+    const url = `${baseUrl}/v1/me`;
+    try {
+        const response = await fetch(url, {
+            headers: {
+                Authorization: `Bearer ${accessToken}`
+            }
+        });
+        if (!response.ok) {
+            throw new FigmaApiError(`Failed to get user info: ${response.status} ${response.statusText}`, response.status);
+        }
+        const data = await response.json();
+        if (!data.id || !data.email || typeof data.handle !== 'string') {
+            throw new FigmaApiError('Invalid user info response: missing required fields');
+        }
+        return data;
+    } catch (error) {
+        if (error instanceof FigmaApiError) {
+            throw error;
+        }
+        throw new FigmaApiError(`Failed to get user info: ${error instanceof Error ? error.message : 'Unknown error'}`, undefined, error instanceof Error ? error : undefined);
+    }
+}
 
 //# sourceMappingURL=figma-api.js.map

package/dist/auth/callback-server.js

@@ -2,6 +2,7 @@ import { readFileSync } from 'fs';
 import { createServer } from 'http';
 import path from 'path';
 import { fileURLToPath } from 'url';
+import { DEFAULT_CALLBACK_PORT } from '../config/oauth.js';
 const filename = fileURLToPath(import.meta.url);
 const dirname = path.dirname(filename);
 /**
@@ -27,7 +28,7 @@ const dirname = path.dirname(filename);
     server = null;
     timeoutMs;
     constructor(options = {}){
-        this.preferredPort = options.port || 3000;
+        this.preferredPort = options.port || DEFAULT_CALLBACK_PORT;
         this.timeoutMs = options.timeoutMs || 120000; // 2 minutes default
         this.server = createServer();
     }

package/dist/auth/crypto-utils.js

@@ -1,11 +1,6 @@
 import Conf from 'conf';
 import crypto from 'crypto';
 import os from 'os';
-// Configuration store for cryptographic salt
-const cryptoConf = new Conf({
-    configName: 'payloadcms-figma-crypto',
-    projectName: 'payloadcms-figma'
-});
 /**
  * Get or generate a random salt for key derivation
  *
@@ -15,6 +10,11 @@ const cryptoConf = new Conf({
  *
  * @returns 32-byte hex string (64 characters)
  */ function getOrCreateSalt() {
+    // Configuration store for cryptographic salt
+    const cryptoConf = new Conf({
+        configName: 'payloadcms-figma-crypto',
+        projectName: 'payloadcms-figma'
+    });
     let salt = cryptoConf.get('salt');
     if (!salt) {
         // Generate cryptographically secure random salt (32 bytes = 256 bits)

package/dist/auth/jwt-validator.d.ts

@@ -1,3 +1,4 @@
+import type { Environment } from '../constants.js';
 import type { JWTPayload } from './types.js';
 /**
  * JWT validation error with specific error codes
@@ -27,7 +28,7 @@ export declare class JWTValidationError extends Error {
  * @returns Promise resolving to validated JWT payload
  * @throws {JWTValidationError} If validation fails
  */
-export declare function validateProjectToken(token: string, environment: 'production' | 'staging'): Promise<JWTPayload>;
+export declare function validateProjectToken(token: string, environment: Environment): Promise<JWTPayload>;
 /**
  * Clear JWKS cache (useful for testing or forcing refresh)
  *

package/dist/auth/jwt-validator.js

@@ -1,6 +1,6 @@
 import { createRemoteJWKSet, jwtVerify } from 'jose';
 import { JWKSMultipleMatchingKeys, JWKSNoMatchingKey, JWSInvalid, JWSSignatureVerificationFailed, JWTExpired } from 'jose/errors';
-import { getJWKSUri } from '../constants.js';
+import { ENV_CONFIG } from '../constants.js';
 /**
  * JWT validation error with specific error codes
  */ export class JWTValidationError extends Error {
@@ -28,7 +28,7 @@ import { getJWKSUri } from '../constants.js';
  * @param environment - Figma environment ('production' or 'staging')
  * @returns JWKS resolver function
  */ function getJWKSResolver(environment) {
-    const jwksUri = getJWKSUri(environment);
+    const jwksUri = ENV_CONFIG[environment].jwksUri;
     if (!jwksResolvers.has(jwksUri)) {
         jwksResolvers.set(jwksUri, createRemoteJWKSet(new URL(jwksUri), {
             cacheMaxAge: 24 * 60 * 60 * 1000,

package/dist/auth/oauth-flow.d.ts

@@ -13,7 +13,7 @@ export declare class OAuthFlowError extends Error {
 export interface OAuthFlowOptions {
     /** OAuth2 client ID (defaults to config) */
     clientId?: string;
-    /** Callback server port (defaults to 3000) */
+    /** Callback server port (defaults to DEFAULT_CALLBACK_PORT) */
     port?: number;
     /** Redirect URI (defaults to config) */
     redirectUri?: string;