playkit-sdk 1.2.8-beta.2 → 1.2.8-beta.4

package/dist/playkit-sdk.cjs.js

@@ -1,5 +1,5 @@
 /**
- * playkit-sdk v1.2.8-beta.2
+ * playkit-sdk v1.2.8-beta.4
  * PlayKit SDK for JavaScript
  * @license SEE LICENSE IN LICENSE
  */
@@ -2394,6 +2394,7 @@ class DeviceAuthFlowManager extends EventEmitter {
 // @ts-ignore - replaced at build time
 const DEFAULT_BASE_URL$5 = "https://api.playkit.ai";
 const JWT_EXCHANGE_ENDPOINT = '/api/external/exchange-jwt';
+const TOKEN_REFRESH_ENDPOINT = '/api/auth/refresh';
 class AuthManager extends EventEmitter {
     constructor(config) {
         super();
@@ -2445,6 +2446,21 @@ class AuthManager extends EventEmitter {
                 this.emit('authenticated', this.authState);
                 return;
             }
+            // Token expired, but check if we can refresh (browser mode only)
+            if (this.config.mode !== 'server' &&
+                savedState.refreshToken &&
+                (!savedState.refreshExpiresAt || Date.now() < savedState.refreshExpiresAt)) {
+                this.logger.debug('Access token expired, attempting refresh');
+                this.authState = savedState; // Load state with refresh token
+                try {
+                    await this.refreshToken();
+                    return; // Successfully refreshed
+                }
+                catch (error) {
+                    this.logger.warn('Token refresh failed during initialization', error);
+                    // Continue to re-authentication
+                }
+            }
         }
         // Check if player JWT was provided
         if (this.config.playerJWT) {
@@ -2494,12 +2510,14 @@ class AuthManager extends EventEmitter {
                 const result = await this.deviceAuthFlowManager.startFlow({
                     scope: 'player:play',
                 });
-                // Update auth state with the player token
+                // Update auth state with the player token and refresh token
                 this.authState = {
                     isAuthenticated: true,
                     token: result.access_token,
                     tokenType: 'player',
                     expiresAt: Date.now() + result.expires_in * 1000,
+                    refreshToken: result.refresh_token,
+                    refreshExpiresAt: Date.now() + result.refresh_expires_in * 1000,
                 };
                 // Save to storage
                 await this.storage.saveAuthState(this.config.gameId, this.authState);
@@ -2598,6 +2616,58 @@ class AuthManager extends EventEmitter {
             return false;
         return Date.now() >= this.authState.expiresAt;
     }
+    /**
+     * Check if token is about to expire (within threshold)
+     * @param thresholdMs - Threshold in milliseconds (default: 5 minutes)
+     */
+    isTokenExpiringSoon(thresholdMs = 5 * 60 * 1000) {
+        if (!this.authState.expiresAt)
+            return false;
+        return Date.now() >= this.authState.expiresAt - thresholdMs;
+    }
+    /**
+     * Ensure the access token is valid, refreshing if needed (browser mode only).
+     * Call this before making API requests to automatically handle token refresh.
+     *
+     * In server mode, this method does nothing (tokens should be managed externally).
+     *
+     * @param thresholdMs - Refresh if token expires within this time (default: 5 minutes)
+     * @returns Promise that resolves when token is valid
+     * @throws PlayKitError if token cannot be refreshed and is expired
+     */
+    async ensureValidToken(thresholdMs = 5 * 60 * 1000) {
+        // Skip auto-refresh in server mode
+        if (this.config.mode === 'server') {
+            return;
+        }
+        // Skip if not authenticated
+        if (!this.authState.isAuthenticated || !this.authState.token) {
+            return;
+        }
+        // Check if token needs refresh
+        if (!this.isTokenExpiringSoon(thresholdMs)) {
+            return; // Token is still valid
+        }
+        // Try to refresh if possible
+        if (this.canRefresh()) {
+            this.logger.debug('Token expiring soon, refreshing automatically');
+            try {
+                await this.refreshToken();
+            }
+            catch (error) {
+                this.logger.warn('Auto-refresh failed', error);
+                // If refresh fails and token is already expired, throw
+                if (this.isTokenExpired()) {
+                    throw error;
+                }
+                // Otherwise, continue with potentially expired token
+            }
+        }
+        else if (this.isTokenExpired()) {
+            // Token expired and cannot refresh
+            throw new PlayKitError('Access token has expired and no refresh token is available', 'TOKEN_EXPIRED');
+        }
+    }
     /**
      * Logout and clear authentication
      */
@@ -2639,12 +2709,14 @@ class AuthManager extends EventEmitter {
         try {
             this.deviceAuthFlowManager = new DeviceAuthFlowManager(this.baseURL, this.config.gameId);
             const result = await this.deviceAuthFlowManager.startFlow(options);
-            // Update auth state with the token
+            // Update auth state with the token and refresh token
             this.authState = {
                 isAuthenticated: true,
                 token: result.access_token,
                 tokenType: result.scope === 'developer:full' ? 'developer' : 'player',
                 expiresAt: Date.now() + result.expires_in * 1000,
+                refreshToken: result.refresh_token,
+                refreshExpiresAt: Date.now() + result.refresh_expires_in * 1000,
             };
             // Save to storage
             await this.storage.saveAuthState(this.config.gameId, this.authState);
@@ -2707,12 +2779,14 @@ class AuthManager extends EventEmitter {
         }
         try {
             const result = await this.deviceAuthFlowManager.pollForToken(sessionId, codeVerifier, options);
-            // Update auth state with the token
+            // Update auth state with the token and refresh token
             this.authState = {
                 isAuthenticated: true,
                 token: result.access_token,
                 tokenType: result.scope === 'developer:full' ? 'developer' : 'player',
                 expiresAt: Date.now() + result.expires_in * 1000,
+                refreshToken: result.refresh_token,
+                refreshExpiresAt: Date.now() + result.refresh_expires_in * 1000,
             };
             // Save to storage
             await this.storage.saveAuthState(this.config.gameId, this.authState);
@@ -2725,6 +2799,91 @@ class AuthManager extends EventEmitter {
             this.deviceAuthFlowManager = null;
         }
     }
+    /**
+     * Check if the current session can be refreshed
+     * @returns true if a valid refresh token exists and has not expired
+     */
+    canRefresh() {
+        if (!this.authState.refreshToken)
+            return false;
+        if (!this.authState.refreshExpiresAt)
+            return true; // No expiry info, assume valid
+        return Date.now() < this.authState.refreshExpiresAt;
+    }
+    /**
+     * Refresh the access token using the stored refresh token
+     *
+     * @returns Promise resolving to TokenRefreshResult with new tokens
+     * @throws PlayKitError if no refresh token is available or refresh fails
+     *
+     * @example
+     * ```ts
+     * if (sdk.isTokenExpired() && authManager.canRefresh()) {
+     *   const result = await authManager.refreshToken();
+     *   console.log('New token expires in:', result.expiresIn, 'seconds');
+     * }
+     * ```
+     */
+    async refreshToken() {
+        if (!this.authState.refreshToken) {
+            throw new PlayKitError('No refresh token available. Please re-authenticate.', 'NO_REFRESH_TOKEN');
+        }
+        if (this.authState.refreshExpiresAt && Date.now() >= this.authState.refreshExpiresAt) {
+            throw new PlayKitError('Refresh token has expired. Please re-authenticate.', 'REFRESH_TOKEN_EXPIRED');
+        }
+        try {
+            this.logger.debug('Refreshing access token');
+            const response = await fetch(`${this.baseURL}${TOKEN_REFRESH_ENDPOINT}`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({
+                    refresh_token: this.authState.refreshToken,
+                }),
+            });
+            if (!response.ok) {
+                const error = await response.json().catch(() => ({ error_description: 'Token refresh failed' }));
+                // If refresh token is invalid, clear auth state
+                if (response.status === 401) {
+                    this.logger.warn('Refresh token invalid, clearing auth state');
+                    await this.logout();
+                    throw new PlayKitError(error.error_description || 'Refresh token is invalid or expired', 'REFRESH_TOKEN_INVALID', response.status);
+                }
+                throw new PlayKitError(error.error_description || 'Token refresh failed', error.error || 'REFRESH_FAILED', response.status);
+            }
+            const data = await response.json();
+            // Update auth state with new tokens
+            this.authState = {
+                isAuthenticated: true,
+                token: data.access_token,
+                tokenType: data.scope === 'developer:full' ? 'developer' : 'player',
+                expiresAt: Date.now() + data.expires_in * 1000,
+                refreshToken: data.refresh_token,
+                refreshExpiresAt: Date.now() + data.refresh_expires_in * 1000,
+            };
+            // Save to storage
+            await this.storage.saveAuthState(this.config.gameId, this.authState);
+            this.logger.info('Access token refreshed successfully');
+            this.emit('authenticated', this.authState);
+            this.emit('token_refreshed', this.authState);
+            return {
+                accessToken: data.access_token,
+                tokenType: data.token_type,
+                expiresIn: data.expires_in,
+                refreshToken: data.refresh_token,
+                refreshExpiresIn: data.refresh_expires_in,
+                scope: data.scope,
+            };
+        }
+        catch (error) {
+            if (error instanceof PlayKitError) {
+                throw error;
+            }
+            this.logger.error('Token refresh failed', error);
+            throw new PlayKitError('Token refresh failed due to network error', 'REFRESH_NETWORK_ERROR');
+        }
+    }
 }
 
 /**
@@ -3578,6 +3737,8 @@ class ChatProvider {
      */
     async chatCompletion(chatConfig) {
         var _a;
+        // Ensure token is valid, auto-refresh if needed (browser mode only)
+        await this.authManager.ensureValidToken();
         const token = this.authManager.getToken();
         if (!token) {
             throw new PlayKitError('Not authenticated', 'NOT_AUTHENTICATED');
@@ -3635,6 +3796,8 @@ class ChatProvider {
      */
     async chatCompletionStream(chatConfig) {
         var _a;
+        // Ensure token is valid, auto-refresh if needed (browser mode only)
+        await this.authManager.ensureValidToken();
         const token = this.authManager.getToken();
         if (!token) {
             throw new PlayKitError('Not authenticated', 'NOT_AUTHENTICATED');
@@ -3823,6 +3986,8 @@ class ChatProvider {
      */
     async generateStructured(schemaName, prompt, model, temperature, schema, schemaDescription) {
         var _a;
+        // Ensure token is valid, auto-refresh if needed (browser mode only)
+        await this.authManager.ensureValidToken();
         const token = this.authManager.getToken();
         if (!token) {
             throw new PlayKitError('Not authenticated', 'NOT_AUTHENTICATED');
@@ -3912,6 +4077,8 @@ class ImageProvider {
      * Generate one or more images
      */
     async generateImages(imageConfig) {
+        // Ensure token is valid, auto-refresh if needed (browser mode only)
+        await this.authManager.ensureValidToken();
         const token = this.authManager.getToken();
         if (!token) {
             throw new PlayKitError('Not authenticated', 'NOT_AUTHENTICATED');
@@ -4023,6 +4190,8 @@ class TranscriptionProvider {
      * Transcribe audio to text
      */
     async transcribe(transcriptionConfig) {
+        // Ensure token is valid, auto-refresh if needed (browser mode only)
+        await this.authManager.ensureValidToken();
         const token = this.authManager.getToken();
         if (!token) {
             throw new PlayKitError('Not authenticated', 'NOT_AUTHENTICATED');
@@ -5970,6 +6139,10 @@ class PlayKitSDK extends EventEmitter {
             this.emit('error', error);
             this.logger.error('Auth error', error);
         });
+        this.authManager.on('token_refreshed', (authState) => {
+            this.emit('token_refreshed', authState);
+            this.logger.debug('Token refreshed', authState);
+        });
         // Forward recharge events
         this.playerClient.on('recharge_opened', () => this.emit('recharge_opened'));
         this.playerClient.on('recharge_modal_shown', () => this.emit('recharge_modal_shown'));
@@ -5979,6 +6152,7 @@ class PlayKitSDK extends EventEmitter {
         this.playerClient.on('balance_updated', (credits) => this.emit('balance_updated', credits));
         this.playerClient.on('player_info_updated', (info) => this.emit('player_info_updated', info));
         this.playerClient.on('daily_credits_refreshed', (result) => this.emit('daily_credits_refreshed', result));
+        this.playerClient.on('nickname_changed', (nickname) => this.emit('nickname_changed', nickname));
     }
     /**
      * Initialize the SDK
@@ -6270,6 +6444,25 @@ class PlayKitSDK extends EventEmitter {
         return playerInfo.credits;
     }
     // ============================================================
+    // Player Profile Methods
+    // ============================================================
+    /**
+     * Get player's nickname (cached)
+     * @returns Nickname or null if not set
+     */
+    getNickname() {
+        return this.playerClient.getNickname();
+    }
+    /**
+     * Set player's nickname for the current game
+     * @param nickname - 1-16 characters (letters, numbers, Chinese, underscores, spaces)
+     * @returns SetNicknameResponse with success status and gameId
+     * @throws PlayKitError if validation fails or token type is invalid
+     */
+    async setNickname(nickname) {
+        return await this.playerClient.setNickname(nickname);
+    }
+    // ============================================================
     // Headless Device Auth Methods (for terminal/CLI environments)
     // ============================================================
     /**
@@ -6317,6 +6510,45 @@ class PlayKitSDK extends EventEmitter {
     cancelLogin() {
         this.authManager.cancelDeviceAuthFlow();
     }
+    // ============================================================
+    // Token Refresh Methods
+    // ============================================================
+    /**
+     * Check if the current token is expired
+     */
+    isTokenExpired() {
+        return this.authManager.isTokenExpired();
+    }
+    /**
+     * Check if the access token can be refreshed
+     * @returns true if a valid refresh token exists
+     */
+    canRefreshToken() {
+        return this.authManager.canRefresh();
+    }
+    /**
+     * Manually refresh the access token using the stored refresh token.
+     *
+     * Note: In browser mode, token refresh is handled automatically before API calls.
+     * This method is useful for:
+     * - Proactively refreshing tokens before they expire
+     * - Server-side applications managing their own token lifecycle
+     *
+     * @returns Promise resolving to TokenRefreshResult with new tokens
+     * @throws PlayKitError if no refresh token is available or refresh fails
+     *
+     * @example
+     * ```ts
+     * // Manual refresh before a long operation
+     * if (sdk.isTokenExpired() && sdk.canRefreshToken()) {
+     *   const result = await sdk.refreshToken();
+     *   console.log('Token refreshed, expires in:', result.expiresIn, 'seconds');
+     * }
+     * ```
+     */
+    async refreshToken() {
+        return this.authManager.refreshToken();
+    }
 }
 
 /**