@multiplayer-app/session-recorder-react-native 0.0.1-beta.4 → 0.0.1-beta.6

package/src/services/screenMaskingService.ts

@@ -0,0 +1,118 @@
+import SessionRecorderNative, { MaskingOptions } from '../native/SessionRecorderNative'
+import { logger } from '../utils'
+import { testNativeModuleAvailability } from '../utils/nativeModuleTest'
+
+export interface ScreenMaskingConfig {
+  /** Whether screen masking is enabled */
+  enabled: boolean
+  /** Whether to mask all input fields automatically */
+  inputMasking: boolean
+  /** Default masking options */
+  defaultOptions?: MaskingOptions
+}
+
+export class ScreenMaskingService {
+  private config: ScreenMaskingConfig
+  private isAvailable: boolean = false
+
+  constructor(config: ScreenMaskingConfig = { enabled: true, inputMasking: true }) {
+    this.config = config
+    this.checkAvailability()
+  }
+
+  /**
+   * Check if the native masking module is available
+   */
+  private checkAvailability(): void {
+    try {
+      // Try to access the native module to check if it's available
+      if (SessionRecorderNative && typeof SessionRecorderNative.captureAndMask === 'function') {
+        this.isAvailable = true
+        logger.info('ScreenMaskingService', 'Screen masking native module is available')
+      } else {
+        this.isAvailable = false
+        logger.warn('ScreenMaskingService', 'Screen masking native module is not available - auto-linking may still be in progress')
+
+        // Run diagnostic test
+        testNativeModuleAvailability()
+
+        // Retry after a delay for auto-linking
+        setTimeout(() => {
+          this.checkAvailability()
+        }, 2000)
+      }
+    } catch (error) {
+      this.isAvailable = false
+      logger.error('ScreenMaskingService', 'Error checking screen masking availability:', error)
+    }
+  }
+
+  /**
+   * Capture screen with masking applied
+   */
+  async captureMaskedScreen(options?: MaskingOptions): Promise<string | null> {
+    if (!this.isAvailable || !this.config.enabled) {
+      logger.warn('ScreenMaskingService', 'Screen masking is not available or disabled')
+      return null
+    }
+
+    try {
+      const maskingOptions: MaskingOptions = {
+        ...this.config.defaultOptions,
+        ...options,
+        inputMasking: this.config.inputMasking,
+      }
+
+      const maskedImageBase64 = await SessionRecorderNative.captureAndMaskWithOptions(maskingOptions)
+      logger.info('ScreenMaskingService', 'Successfully captured masked screen')
+      return maskedImageBase64
+    } catch (error) {
+      logger.error('ScreenMaskingService', 'Failed to capture masked screen:', error)
+      return null
+    }
+  }
+
+  /**
+   * Capture screen with basic masking (no custom options)
+   */
+  async captureMaskedScreenBasic(): Promise<string | null> {
+    if (!this.isAvailable || !this.config.enabled) {
+      logger.warn('ScreenMaskingService', 'Screen masking is not available or disabled')
+      return null
+    }
+
+    try {
+      const maskedImageBase64 = await SessionRecorderNative.captureAndMask()
+      logger.info('ScreenMaskingService', 'Successfully captured masked screen (basic)')
+      return maskedImageBase64
+    } catch (error) {
+      logger.error('ScreenMaskingService', 'Failed to capture masked screen (basic):', error)
+      return null
+    }
+  }
+
+  /**
+   * Update the masking configuration
+   */
+  updateConfig(config: Partial<ScreenMaskingConfig>): void {
+    this.config = { ...this.config, ...config }
+    logger.info('ScreenMaskingService', 'Screen masking configuration updated')
+  }
+
+  /**
+   * Check if screen masking is available
+   */
+  isScreenMaskingAvailable(): boolean {
+    return this.isAvailable && this.config.enabled
+  }
+
+  /**
+   * Get the current configuration
+   */
+  getConfig(): ScreenMaskingConfig {
+    return { ...this.config }
+  }
+}
+
+// Create a singleton instance
+export const screenMaskingService = new ScreenMaskingService()

package/src/types/session-recorder.ts

@@ -150,7 +150,6 @@ export interface MaskingConfig {
   /** Custom function for masking headers in traces */
   maskHeaders?: (headers: any, span: any) => any;
 
-
   /** List of body fields to mask in traces */
   maskBodyFieldsList?: string[]
   /** List of headers to mask in traces */
@@ -160,6 +159,11 @@ export interface MaskingConfig {
   headersToInclude?: string[]
   /** List of headers to exclude from traces */
   headersToExclude?: string[]
+
+  /** Whether to mask all input fields during screen recording
+   *  @default true
+  */
+  inputMasking?: boolean
 }
 
 /**
@@ -222,6 +226,8 @@ export interface RecorderConfig extends BaseConfig {
   recordNavigation?: boolean
   /** Whether to record screen */
   recordScreen?: boolean
+  /** Configuration for masking sensitive data in session recordings */
+  masking?: MaskingConfig
 }
 
 /**

package/src/utils/nativeModuleTest.ts

@@ -0,0 +1,60 @@
+import { NativeModules } from 'react-native'
+import { logger } from './logger'
+
+/**
+ * Test function to verify native module availability
+ */
+export function testNativeModuleAvailability(): void {
+  logger.info('NativeModuleTest', 'Testing native module availability...')
+
+  // Log all available native modules
+  const availableModules = Object.keys(NativeModules)
+  logger.info('NativeModuleTest', `Available native modules: ${availableModules.join(', ')}`)
+
+  // Check specifically for SessionRecorderNative
+  const { SessionRecorderNative } = NativeModules
+
+  if (SessionRecorderNative) {
+    logger.info('NativeModuleTest', '✅ SessionRecorderNative module is available!')
+
+    // Test if the methods exist
+    if (typeof SessionRecorderNative.captureAndMask === 'function') {
+      logger.info('NativeModuleTest', '✅ captureAndMask method is available!')
+    } else {
+      logger.warn('NativeModuleTest', '❌ captureAndMask method is not available')
+    }
+
+    if (typeof SessionRecorderNative.captureAndMaskWithOptions === 'function') {
+      logger.info('NativeModuleTest', '✅ captureAndMaskWithOptions method is available!')
+    } else {
+      logger.warn('NativeModuleTest', '❌ captureAndMaskWithOptions method is not available')
+    }
+  } else {
+    logger.error('NativeModuleTest', '❌ SessionRecorderNative module is not available')
+    logger.info('NativeModuleTest', 'This could mean:')
+    logger.info('NativeModuleTest', '1. Auto-linking has not completed yet')
+    logger.info('NativeModuleTest', '2. The native module was not properly built')
+    logger.info('NativeModuleTest', '3. The module name does not match')
+  }
+}
+
+/**
+ * Test function to verify auto-linking configuration
+ */
+export function testAutoLinkingConfig(): void {
+  logger.info('NativeModuleTest', 'Testing auto-linking configuration...')
+
+  // Check if react-native.config.js exists and is properly configured
+  try {
+    const config = require('../../react-native.config.js')
+    logger.info('NativeModuleTest', '✅ react-native.config.js found')
+
+    if (config.dependencies && config.dependencies['react-native-session-recorder']) {
+      logger.info('NativeModuleTest', '✅ Auto-linking configuration found for react-native-session-recorder')
+    } else {
+      logger.warn('NativeModuleTest', '❌ Auto-linking configuration not found for react-native-session-recorder')
+    }
+  } catch (error) {
+    logger.warn('NativeModuleTest', '❌ react-native.config.js not found or invalid')
+  }
+}