unified-video-framework 1.4.412 → 1.4.413

package/packages/web/src/drm/DRMManager.ts

@@ -1,99 +1,213 @@
 /**
  * DRM Manager
- * Main orchestrator for web DRM - detects browser and initializes appropriate handler
+ * Main orchestrator for all DRM systems
+ * Provides a unified interface for HLS.js, dash.js, and native playback
  */
 
-import { IDRMHandler, WebDRMConfig, DRMError } from './types/DRMTypes';
-import { WidevineDRMHandler } from './WidevineDRMHandler';
-import { FairPlayDRMHandler } from './FairPlayDRMHandler';
+import { DRMType, DRMConfig } from '@unified-video/core';
+import { ExtendedDRMConfig, DRMInitResult, DRMError, DRMErrorCode, DRMCapabilities } from './types/DRMTypes';
+import { BrowserDetector } from './utils/BrowserDetector';
+import { BunnyNetProvider } from './providers/BunnyNetProvider';
+import { WidevineDRM } from './systems/WidevineDRM';
+import { FairPlayDRM } from './systems/FairPlayDRM';
+import { PlayReadyDRM } from './systems/PlayReadyDRM';
+import { BaseDRM } from './systems/BaseDRM';
+import { DRMErrorHandler } from './utils/DRMErrorHandler';
 
 export class DRMManager {
-  private handler: IDRMHandler | null = null;
-  private config: WebDRMConfig;
+  private videoElement: HTMLVideoElement;
+  private config: ExtendedDRMConfig;
+  private drmSystem: BaseDRM | null = null;
+  private browserDetector: BrowserDetector;
+  private debug: boolean = false;
 
-  constructor(config: WebDRMConfig) {
-    this.config = config;
+  constructor(videoElement: HTMLVideoElement, config: DRMConfig, debug: boolean = false) {
+    this.videoElement = videoElement;
+    this.config = this.normalizeConfig(config);
+    this.debug = debug || this.config.debug || false;
+    this.browserDetector = BrowserDetector.getInstance();
   }
 
   /**
-   * Detect browser and return appropriate DRM handler
+   * Initialize DRM system based on browser capabilities
    */
-  private detectDRMHandler(): IDRMHandler {
-    const userAgent = navigator.userAgent.toLowerCase();
-    const isSafari = /^((?!chrome|android).)*safari/i.test(navigator.userAgent);
-
-    if (isSafari) {
-      console.log('[DRM] Detected Safari - using FairPlay DRM');
-      return new FairPlayDRMHandler(this.config);
-    } else {
-      console.log('[DRM] Detected non-Safari browser - using Widevine DRM');
-      return new WidevineDRMHandler(this.config);
+  async initialize(): Promise<DRMInitResult> {
+    try {
+      this.log('Initializing DRM system...');
+
+      // Detect browser capabilities
+      const capabilities = await this.browserDetector.detectCapabilities();
+      this.log('Browser DRM capabilities:', capabilities);
+
+      // Determine which DRM system to use
+      const drmType = this.selectDRMType(capabilities);
+      if (!drmType) {
+        const browserName = this.browserDetector.getBrowserName();
+        throw DRMErrorHandler.createError(
+          DRMErrorCode.UNSUPPORTED_BROWSER,
+          `No supported DRM system found in ${browserName}. Please use Chrome, Safari, Firefox, or Edge.`,
+          true,
+          { browser: browserName, capabilities }
+        );
+      }
+
+      this.log(`Selected DRM type: ${drmType}`);
+
+      // Create appropriate DRM system
+      this.drmSystem = this.createDRMSystem(drmType);
+
+      // Initialize the DRM system
+      await this.drmSystem.initialize();
+
+      return {
+        success: true,
+        drmType,
+        keySystem: this.drmSystem.getKeySystem(),
+      };
+    } catch (error: any) {
+      this.log('DRM initialization failed:', error);
+
+      const drmError = error.code && error.code.startsWith('DRM_')
+        ? error
+        : DRMErrorHandler.createError(
+            DRMErrorCode.CONFIGURATION_ERROR,
+            error.message || 'DRM initialization failed',
+            true,
+            error
+          );
+
+      return {
+        success: false,
+        drmType: this.config.type,
+        keySystem: '',
+        error: drmError,
+      };
     }
   }
 
   /**
-   * Initialize DRM system
+   * Get HLS.js configuration for DRM
    */
-  async initialize(): Promise<void> {
-    console.log('[DRM] Initializing DRM Manager...');
+  getHLSConfig(): any {
+    if (!this.drmSystem) {
+      throw new Error('DRM system not initialized. Call initialize() first.');
+    }
 
-    try {
-      // Detect and create appropriate handler
-      this.handler = this.detectDRMHandler();
-
-      // Check if DRM is supported
-      if (!this.handler.isSupported()) {
-        throw new DRMError(
-          'DRM is not supported in this browser',
-          'DRM_NOT_SUPPORTED'
-        );
-      }
+    return this.drmSystem.getHLSConfig();
+  }
 
-      // Initialize the handler
-      await this.handler.initialize();
-      console.log('[DRM] DRM Manager initialized successfully');
+  /**
+   * Get dash.js protection data for DRM
+   */
+  getDashProtectionData(): any {
+    if (!this.drmSystem) {
+      throw new Error('DRM system not initialized. Call initialize() first.');
+    }
 
-    } catch (error) {
-      console.error('[DRM] Failed to initialize DRM Manager:', error);
-      throw error;
+    return this.drmSystem.getDashProtectionData();
+  }
+
+  /**
+   * Cleanup DRM resources
+   */
+  async destroy(): Promise<void> {
+    if (this.drmSystem) {
+      this.log('Destroying DRM system');
+      await this.drmSystem.destroy();
+      this.drmSystem = null;
     }
   }
 
   /**
-   * Setup DRM for video element and manifest
+   * Select appropriate DRM type based on config and capabilities
    */
-  async setupDRM(videoElement: HTMLVideoElement, manifestUrl: string): Promise<void> {
-    if (!this.handler) {
-      throw new DRMError('DRM Manager not initialized', 'DRM_NOT_INITIALIZED');
+  private selectDRMType(capabilities: DRMCapabilities): DRMType | null {
+    // If config specifies a type and it's supported, use it
+    if (this.config.type) {
+      const typeSupported = this.isDRMTypeSupported(this.config.type, capabilities);
+      if (typeSupported) {
+        return this.config.type;
+      }
+
+      this.log(`Requested DRM type ${this.config.type} not supported, falling back to browser default`);
     }
 
-    console.log('[DRM] Setting up DRM for video element');
-    await this.handler.setupDRM(videoElement, manifestUrl);
+    // Otherwise, use browser's preferred DRM system
+    return capabilities.supportedType;
   }
 
   /**
-   * Check if DRM is currently active
+   * Check if specific DRM type is supported
    */
-  isActive(): boolean {
-    return this.handler !== null;
+  private isDRMTypeSupported(drmType: DRMType, capabilities: DRMCapabilities): boolean {
+    switch (drmType) {
+      case DRMType.WIDEVINE:
+        return capabilities.widevine;
+      case DRMType.FAIRPLAY:
+        return capabilities.fairplay;
+      case DRMType.PLAYREADY:
+        return capabilities.playready;
+      default:
+        return false;
+    }
   }
 
   /**
-   * Get current DRM handler type
+   * Create DRM system instance
    */
-  getHandlerType(): 'widevine' | 'fairplay' | null {
-    if (!this.handler) return null;
-    return this.handler instanceof FairPlayDRMHandler ? 'fairplay' : 'widevine';
+  private createDRMSystem(drmType: DRMType): BaseDRM {
+    switch (drmType) {
+      case DRMType.FAIRPLAY:
+        return new FairPlayDRM(this.videoElement, this.config, this.debug);
+
+      case DRMType.WIDEVINE:
+        return new WidevineDRM(this.videoElement, this.config, this.debug);
+
+      case DRMType.PLAYREADY:
+        return new PlayReadyDRM(this.videoElement, this.config, this.debug);
+
+      default:
+        throw DRMErrorHandler.createError(
+          DRMErrorCode.CONFIGURATION_ERROR,
+          `Unsupported DRM type: ${drmType}`,
+          true
+        );
+    }
   }
 
   /**
-   * Cleanup DRM resources
+   * Normalize and enrich DRM config
+   */
+  private normalizeConfig(config: DRMConfig): ExtendedDRMConfig {
+    const extended = { ...config } as ExtendedDRMConfig;
+
+    // Auto-detect Bunny.net and enhance config
+    if (BunnyNetProvider.isBunnyNetConfig(config)) {
+      extended.provider = 'bunny';
+
+      // Extract IDs if available
+      const ids = BunnyNetProvider.extractIdsFromUrl(config.licenseUrl);
+      if (ids.libraryId) extended.libraryId = ids.libraryId;
+      if (ids.videoId) extended.videoId = ids.videoId;
+
+      this.log('Detected Bunny.net DRM configuration');
+    }
+
+    // Set defaults
+    extended.retryConfig = extended.retryConfig || {
+      maxRetries: 3,
+      retryDelay: 1000,
+    };
+
+    return extended;
+  }
+
+  /**
+   * Debug logging
    */
-  destroy(): void {
-    if (this.handler) {
-      console.log('[DRM] Destroying DRM Manager');
-      this.handler.destroy();
-      this.handler = null;
+  private log(...args: any[]): void {
+    if (this.debug) {
+      console.log('[DRMManager]', ...args);
     }
   }
 }

package/packages/web/src/drm/index.ts

@@ -0,0 +1,37 @@
+/**
+ * DRM System - Public API
+ * Exports for the DRM system
+ */
+
+// Main DRM Manager
+export { DRMManager } from './DRMManager';
+
+// Providers
+export { BunnyNetProvider } from './providers/BunnyNetProvider';
+export { GenericProvider } from './providers/GenericProvider';
+
+// Types
+export type {
+  ExtendedDRMConfig,
+  DRMCapabilities,
+  LicenseRequest,
+  LicenseResponse,
+  DRMInitResult,
+  DRMError,
+} from './types/DRMTypes';
+
+export { DRMErrorCode, KEY_SYSTEMS } from './types/DRMTypes';
+
+export type { BunnyNetConfig, BunnyNetEndpoints } from './types/BunnyNetTypes';
+export { BUNNY_NET_BASE_URL, BUNNY_NET_ENDPOINTS } from './types/BunnyNetTypes';
+
+// Utilities
+export { BrowserDetector } from './utils/BrowserDetector';
+export { DRMErrorHandler } from './utils/DRMErrorHandler';
+export { CertificateManager } from './utils/CertificateManager';
+
+// DRM Systems (for advanced usage)
+export { BaseDRM } from './systems/BaseDRM';
+export { WidevineDRM } from './systems/WidevineDRM';
+export { FairPlayDRM } from './systems/FairPlayDRM';
+export { PlayReadyDRM } from './systems/PlayReadyDRM';

package/packages/web/src/drm/providers/BunnyNetProvider.ts

@@ -0,0 +1,170 @@
+/**
+ * Bunny.net DRM Provider
+ * Helper utilities for Bunny.net MediaCage DRM integration
+ */
+
+import { DRMType, DRMConfig } from '@unified-video/core';
+import { ExtendedDRMConfig } from '../types/DRMTypes';
+import { BunnyNetConfig, BUNNY_NET_ENDPOINTS } from '../types/BunnyNetTypes';
+
+export class BunnyNetProvider {
+  /**
+   * Generate complete DRM config from Bunny.net credentials
+   */
+  static createDRMConfig(config: BunnyNetConfig): ExtendedDRMConfig {
+    const { libraryId, videoId, drmType = DRMType.WIDEVINE } = config;
+
+    const drmConfig: ExtendedDRMConfig = {
+      type: drmType,
+      licenseUrl: this.getLicenseUrl(drmType, libraryId, videoId),
+      provider: 'bunny',
+      libraryId,
+      videoId,
+    };
+
+    // Add FairPlay-specific settings
+    if (drmType === DRMType.FAIRPLAY) {
+      drmConfig.certificateUrl = this.getCertificateUrl(libraryId);
+      drmConfig.fairplayOptions = {
+        certificateUrl: this.getCertificateUrl(libraryId),
+        licenseUrl: this.getLicenseUrl(drmType, libraryId, videoId),
+      };
+    }
+
+    // Add Widevine-specific settings
+    if (drmType === DRMType.WIDEVINE) {
+      drmConfig.widevineOptions = {
+        licenseUrl: this.getLicenseUrl(drmType, libraryId, videoId),
+      };
+    }
+
+    // Add PlayReady-specific settings
+    if (drmType === DRMType.PLAYREADY) {
+      drmConfig.playreadyOptions = {
+        licenseUrl: this.getLicenseUrl(drmType, libraryId, videoId),
+      };
+    }
+
+    return drmConfig;
+  }
+
+  /**
+   * Get license URL for specific DRM type
+   */
+  static getLicenseUrl(drmType: DRMType, libraryId: string, videoId: string): string {
+    switch (drmType) {
+      case DRMType.WIDEVINE:
+        return BUNNY_NET_ENDPOINTS.WIDEVINE_LICENSE(libraryId, videoId);
+
+      case DRMType.FAIRPLAY:
+        return BUNNY_NET_ENDPOINTS.FAIRPLAY_LICENSE(libraryId, videoId);
+
+      case DRMType.PLAYREADY:
+        return BUNNY_NET_ENDPOINTS.PLAYREADY_LICENSE(libraryId, videoId);
+
+      default:
+        throw new Error(`Unsupported DRM type for Bunny.net: ${drmType}`);
+    }
+  }
+
+  /**
+   * Get certificate URL (FairPlay only)
+   */
+  static getCertificateUrl(libraryId: string): string {
+    return BUNNY_NET_ENDPOINTS.FAIRPLAY_CERTIFICATE(libraryId);
+  }
+
+  /**
+   * Validate Bunny.net DRM configuration
+   */
+  static validateConfig(config: BunnyNetConfig): { valid: boolean; error?: string } {
+    if (!config.libraryId || !config.videoId) {
+      return {
+        valid: false,
+        error: 'Bunny.net DRM requires libraryId and videoId',
+      };
+    }
+
+    if (!/^\d+$/.test(config.libraryId)) {
+      return {
+        valid: false,
+        error: 'libraryId must be a numeric string',
+      };
+    }
+
+    return { valid: true };
+  }
+
+  /**
+   * Auto-detect if a DRM config is for Bunny.net
+   */
+  static isBunnyNetConfig(config: DRMConfig): boolean {
+    return !!(
+      config.licenseUrl?.includes('bunnycdn.com') ||
+      config.certificateUrl?.includes('bunnycdn.com') ||
+      config.fairplayOptions?.licenseUrl?.includes('bunnycdn.com') ||
+      config.fairplayOptions?.certificateUrl?.includes('bunnycdn.com') ||
+      config.widevineOptions?.licenseUrl?.includes('bunnycdn.com') ||
+      config.playreadyOptions?.licenseUrl?.includes('bunnycdn.com')
+    );
+  }
+
+  /**
+   * Extract library and video IDs from Bunny.net URLs
+   */
+  static extractIdsFromUrl(url: string): { libraryId?: string; videoId?: string } {
+    if (!url) return {};
+
+    const widevineMatch = url.match(/WidevineLicense\/([^/]+)\/([^/?]+)/);
+    const fairplayLicenseMatch = url.match(/FairPlay\/([^/]+)\/license.*videoId=([^&]+)/);
+    const fairplayCertMatch = url.match(/FairPlay\/([^/]+)\/certificate/);
+    const playreadyMatch = url.match(/PlayReadyLicense\/([^/]+)\/([^/?]+)/);
+
+    if (widevineMatch) {
+      return { libraryId: widevineMatch[1], videoId: widevineMatch[2] };
+    }
+    if (fairplayLicenseMatch) {
+      return { libraryId: fairplayLicenseMatch[1], videoId: fairplayLicenseMatch[2] };
+    }
+    if (fairplayCertMatch) {
+      return { libraryId: fairplayCertMatch[1] };
+    }
+    if (playreadyMatch) {
+      return { libraryId: playreadyMatch[1], videoId: playreadyMatch[2] };
+    }
+
+    return {};
+  }
+
+  /**
+   * Create multi-DRM config for Bunny.net (auto-detects browser)
+   */
+  static createMultiDRMConfig(libraryId: string, videoId: string): ExtendedDRMConfig {
+    // Primary Widevine config with FairPlay fallback
+    const config: ExtendedDRMConfig = {
+      type: DRMType.WIDEVINE,
+      licenseUrl: this.getLicenseUrl(DRMType.WIDEVINE, libraryId, videoId),
+      provider: 'bunny',
+      libraryId,
+      videoId,
+
+      // Widevine options
+      widevineOptions: {
+        licenseUrl: this.getLicenseUrl(DRMType.WIDEVINE, libraryId, videoId),
+      },
+
+      // FairPlay options (for Safari fallback)
+      fairplayOptions: {
+        certificateUrl: this.getCertificateUrl(libraryId),
+        licenseUrl: this.getLicenseUrl(DRMType.FAIRPLAY, libraryId, videoId),
+      },
+
+      // PlayReady options (for Edge fallback)
+      playreadyOptions: {
+        licenseUrl: this.getLicenseUrl(DRMType.PLAYREADY, libraryId, videoId),
+      },
+    };
+
+    return config;
+  }
+}

package/packages/web/src/drm/providers/GenericProvider.ts

@@ -0,0 +1,148 @@
+/**
+ * Generic DRM Provider
+ * Helper utilities for generic DRM configurations
+ */
+
+import { DRMType, DRMConfig } from '@unified-video/core';
+import { ExtendedDRMConfig } from '../types/DRMTypes';
+
+export class GenericProvider {
+  /**
+   * Create generic DRM config with sensible defaults
+   */
+  static createDRMConfig(config: {
+    drmType: DRMType;
+    licenseUrl: string;
+    certificateUrl?: string;
+    headers?: Record<string, string>;
+    customData?: string;
+  }): ExtendedDRMConfig {
+    const drmConfig: ExtendedDRMConfig = {
+      type: config.drmType,
+      licenseUrl: config.licenseUrl,
+      certificateUrl: config.certificateUrl,
+      headers: config.headers,
+      customData: config.customData,
+      provider: 'generic',
+    };
+
+    // Add type-specific options
+    switch (config.drmType) {
+      case DRMType.FAIRPLAY:
+        if (config.certificateUrl) {
+          drmConfig.fairplayOptions = {
+            certificateUrl: config.certificateUrl,
+            licenseUrl: config.licenseUrl,
+          };
+        }
+        break;
+
+      case DRMType.WIDEVINE:
+        drmConfig.widevineOptions = {
+          licenseUrl: config.licenseUrl,
+        };
+        break;
+
+      case DRMType.PLAYREADY:
+        drmConfig.playreadyOptions = {
+          licenseUrl: config.licenseUrl,
+          customData: config.customData,
+        };
+        break;
+    }
+
+    return drmConfig;
+  }
+
+  /**
+   * Validate generic DRM configuration
+   */
+  static validateConfig(config: DRMConfig): { valid: boolean; error?: string } {
+    if (!config.type) {
+      return {
+        valid: false,
+        error: 'DRM type is required',
+      };
+    }
+
+    if (!config.licenseUrl) {
+      return {
+        valid: false,
+        error: 'License URL is required',
+      };
+    }
+
+    // FairPlay requires certificate URL
+    if (config.type === DRMType.FAIRPLAY) {
+      const certificateUrl = config.certificateUrl || config.fairplayOptions?.certificateUrl;
+      if (!certificateUrl) {
+        return {
+          valid: false,
+          error: 'FairPlay requires certificateUrl',
+        };
+      }
+    }
+
+    // Validate URL format
+    try {
+      new URL(config.licenseUrl);
+    } catch (e) {
+      return {
+        valid: false,
+        error: 'Invalid license URL format',
+      };
+    }
+
+    if (config.certificateUrl) {
+      try {
+        new URL(config.certificateUrl);
+      } catch (e) {
+        return {
+          valid: false,
+          error: 'Invalid certificate URL format',
+        };
+      }
+    }
+
+    return { valid: true };
+  }
+
+  /**
+   * Create multi-DRM config for generic provider
+   */
+  static createMultiDRMConfig(config: {
+    widevine: { licenseUrl: string };
+    fairplay: { licenseUrl: string; certificateUrl: string };
+    playready?: { licenseUrl: string; customData?: string };
+    headers?: Record<string, string>;
+  }): ExtendedDRMConfig {
+    // Primary Widevine config with FairPlay and PlayReady fallbacks
+    const drmConfig: ExtendedDRMConfig = {
+      type: DRMType.WIDEVINE,
+      licenseUrl: config.widevine.licenseUrl,
+      provider: 'generic',
+      headers: config.headers,
+
+      // Widevine options
+      widevineOptions: {
+        licenseUrl: config.widevine.licenseUrl,
+      },
+
+      // FairPlay options
+      fairplayOptions: {
+        certificateUrl: config.fairplay.certificateUrl,
+        licenseUrl: config.fairplay.licenseUrl,
+      },
+
+      // PlayReady options (optional)
+      playreadyOptions: config.playready
+        ? {
+            licenseUrl: config.playready.licenseUrl,
+            customData: config.playready.customData,
+          }
+        : undefined,
+    };
+
+    return drmConfig;
+  }
+}

package/packages/web/src/drm/systems/BaseDRM.ts

@@ -0,0 +1,68 @@
+/**
+ * Base DRM System
+ * Abstract base class for all DRM system implementations
+ */
+
+import { ExtendedDRMConfig, LicenseRequest, LicenseResponse } from '../types/DRMTypes';
+import { LicenseRequestHandler } from '../utils/LicenseRequestHandler';
+
+export abstract class BaseDRM {
+  protected videoElement: HTMLVideoElement;
+  protected config: ExtendedDRMConfig;
+  protected debug: boolean;
+  protected licenseHandler: LicenseRequestHandler;
+  protected mediaKeys: MediaKeys | null = null;
+  protected keySession: MediaKeySession | null = null;
+
+  constructor(videoElement: HTMLVideoElement, config: ExtendedDRMConfig, debug: boolean = false) {
+    this.videoElement = videoElement;
+    this.config = config;
+    this.debug = debug;
+    this.licenseHandler = new LicenseRequestHandler(config, debug);
+  }
+
+  /**
+   * Initialize DRM system
+   */
+  abstract initialize(): Promise<void>;
+
+  /**
+   * Get key system identifier
+   */
+  abstract getKeySystem(): string;
+
+  /**
+   * Get HLS.js configuration
+   */
+  abstract getHLSConfig(): any;
+
+  /**
+   * Get dash.js protection data
+   */
+  abstract getDashProtectionData(): any;
+
+  /**
+   * Cleanup resources
+   */
+  async destroy(): Promise<void> {
+    if (this.keySession) {
+      try {
+        await this.keySession.close();
+      } catch (error) {
+        this.log('Error closing key session:', error);
+      }
+      this.keySession = null;
+    }
+
+    this.mediaKeys = null;
+  }
+
+  /**
+   * Debug logging
+   */
+  protected log(...args: any[]): void {
+    if (this.debug) {
+      console.log(`[${this.constructor.name}]`, ...args);
+    }
+  }
+}