@bota.dev/react-native-app-sdk 2.0.0-beta.0 → 2.0.0-beta.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bota.dev/react-native-app-sdk",
-  "version": "2.0.0-beta.0",
+  "version": "2.0.0-beta.3",
   "description": "React Native facade for the Bota App SDK",
   "packageManager": "npm@12.0.2",
   "main": "lib/commonjs/index.js",

package/scripts/bota_device_sdk_spm_workaround.rb

@@ -25,29 +25,40 @@ module BotaDeviceSDKSPMWorkaround
     end
 
     rewrite_aggregate_modulemap_references(installer)
+    installer.pod_targets.each do |pod_target|
+      pod_target.build_settings.each do |configuration_name, build_settings|
+        path = pod_target.xcconfig_path(configuration_name)
+        # Expo can re-save this cached config after the SPM post-install hook.
+        rewrite_modulemap_config(build_settings.xcconfig, path)
+      end
+    end
   end
 
   def self.rewrite_aggregate_modulemap_references(installer)
-    nested = "${PODS_CONFIGURATION_BUILD_DIR}/#{POD_NAME}/#{POD_NAME}.modulemap"
-    flattened = "${PODS_CONFIGURATION_BUILD_DIR}/#{POD_NAME}.modulemap"
-
     installer.aggregate_targets.each do |aggregate_target|
       aggregate_target.xcconfigs.each do |configuration_name, config_file|
-        changed = false
-        %w[OTHER_CFLAGS OTHER_SWIFT_FLAGS].each do |key|
-          value = config_file.attributes[key]
-          next unless value
-
-          updated = value.gsub(nested, flattened)
-          next if updated == value
-
-          config_file.attributes[key] = updated
-          changed = true
-        end
-        config_file.save_as(aggregate_target.xcconfig_path(configuration_name)) if changed
+        rewrite_modulemap_config(config_file, aggregate_target.xcconfig_path(configuration_name))
       end
     end
   end
 
+  def self.rewrite_modulemap_config(config_file, path)
+    nested = "${PODS_CONFIGURATION_BUILD_DIR}/#{POD_NAME}/#{POD_NAME}.modulemap"
+    flattened = "${PODS_CONFIGURATION_BUILD_DIR}/#{POD_NAME}.modulemap"
+    changed = false
+    %w[OTHER_CFLAGS OTHER_SWIFT_FLAGS].each do |key|
+      value = config_file.attributes[key]
+      next unless value
+
+      updated = value.gsub(nested, flattened)
+      next if updated == value
+
+      config_file.attributes[key] = updated
+      changed = true
+    end
+    config_file.save_as(path) if changed
+  end
+
   private_class_method :rewrite_aggregate_modulemap_references
+  private_class_method :rewrite_modulemap_config
 end

package/src/BotaClient.ts

@@ -5,6 +5,7 @@ import { getCompatibilityClient } from './compatibility/runtime';
 import { DeviceManager } from './managers/DeviceManager';
 import { OTAManager } from './managers/OTAManager';
 import { RecordingManager } from './managers/RecordingManager';
+import { rejectRecordingDataStore } from './managers/uploadRecoveryMetadata';
 import type {
   BluetoothState,
   BotaClientEvents,
@@ -17,12 +18,16 @@ import { logger, type LogHandler } from './utils/logger';
 
 const log = logger.tag('BotaClient');
 
-const normalizeConfig = (config: BotaConfig): Required<BotaConfig> => ({
+type NormalizedConfig = Required<Omit<BotaConfig, 'uploadRecoveryProvider' | 'recordingDataStore'>> &
+  Pick<BotaConfig, 'uploadRecoveryProvider'>;
+
+const normalizeConfig = (config: BotaConfig): NormalizedConfig => ({
   environment: config.environment ?? 'production',
   backgroundSyncEnabled: config.backgroundSyncEnabled ?? true,
   wifiOnlyUpload: config.wifiOnlyUpload ?? false,
   logLevel: config.logLevel ?? 'warn',
   debug: config.debug ?? false,
+  ...(config.uploadRecoveryProvider ? { uploadRecoveryProvider: config.uploadRecoveryProvider } : {}),
 });
 
 class BotaClientImpl extends EventEmitter<BotaClientEvents> {
@@ -74,6 +79,11 @@ class BotaClientImpl extends EventEmitter<BotaClientEvents> {
   }
 
   configure(config: BotaConfig = {}): Promise<void> {
+    try {
+      rejectRecordingDataStore(config.recordingDataStore);
+    } catch (error) {
+      return Promise.reject(error);
+    }
     if (this._configurePromise && !this._destroyPromise) {
       return this._configurePromise;
     }
@@ -141,7 +151,7 @@ class BotaClientImpl extends EventEmitter<BotaClientEvents> {
     return queued;
   }
 
-  private async performConfigure(config: Required<BotaConfig>): Promise<void> {
+  private async performConfigure(config: NormalizedConfig): Promise<void> {
     if (this._state !== 'uninitialized' || this._nativeOwned) {
       log.warn('SDK already configured, reconfiguring');
       await this.releaseOwnerGraph();
@@ -170,7 +180,7 @@ class BotaClientImpl extends EventEmitter<BotaClientEvents> {
 
       deviceManager = new DeviceManager();
       await deviceManager.initialize();
-      recordingManager = new RecordingManager();
+      recordingManager = new RecordingManager({ uploadRecoveryProvider: config.uploadRecoveryProvider });
       await recordingManager.initialize();
       otaManager = new OTAManager(deviceManager);
 

package/src/ble/constants.ts

@@ -1,3 +1,8 @@
 export const DEVICE_LOG_FLAG_BACKLOG = 0x01;
 export const DEVICE_LOG_FLAG_DROPPED = 0x02;
 export const BLE_ERROR_STORAGE_KEY_UNAVAILABLE = 0x14;
+
+export const DEVICE_DIAGNOSTICS_EVT_META = 0x90;
+export const DEVICE_DIAGNOSTICS_EVT_SIGNATURE = 0x91;
+export const DEVICE_DIAGNOSTICS_EVT_END = 0x92;
+export const DEVICE_DIAGNOSTICS_EVT_DETAIL = 0x95;

package/src/ble/deviceDiagnostics.ts

@@ -0,0 +1,238 @@
+import { Buffer } from 'buffer';
+
+import {
+  DEVICE_DIAGNOSTICS_EVT_END,
+  DEVICE_DIAGNOSTICS_EVT_DETAIL,
+  DEVICE_DIAGNOSTICS_EVT_META,
+  DEVICE_DIAGNOSTICS_EVT_SIGNATURE,
+} from './constants';
+import type {
+  DeviceDiagnosticEvent,
+  DeviceDiagnosticEventType,
+  DeviceDiagnosticReasonCode,
+  DeviceDiagnosticsBatch,
+} from '../models/Device';
+
+const EVENT_TYPES: Record<number, DeviceDiagnosticEventType> = {
+  1: 'reset', 2: 'watchdog', 3: 'hard_fault', 4: 'storage',
+  5: 'power', 6: 'radio', 7: 'security',
+};
+const REASONS: Record<number, DeviceDiagnosticReasonCode> = {
+  1: 'watchdog_timeout', 2: 'cpu_illegal_instruction',
+  3: 'cpu_misaligned_access', 4: 'cpu_stack_overflow',
+  5: 'cpu_usage_fault', 6: 'memory_protection_fault',
+  7: 'invalid_register_read', 8: 'invalid_register_write',
+  9: 'audio_subsystem_fault', 10: 'wireless_subsystem_fault',
+  11: 'flash_mmu_fault', 12: 'low_voltage_reset',
+  255: 'unknown_cpu_exception',
+};
+const SUBSYSTEMS: Record<number, string> = {
+  0: 'system', 1: 'audio', 2: 'wireless', 3: 'storage',
+  4: 'power', 5: 'security',
+};
+const STATES: Record<number, string> = {
+  0: 'boot', 1: 'deep_standby', 2: 'recording', 3: 'upload_preparing',
+  4: 'uploading', 5: 'error_recovery', 6: 'full_sleep',
+};
+const BREADCRUMBS: Record<number, string> = {
+  1: 'boot', 2: 'standby_entered', 3: 'recording_started',
+  4: 'upload_preparing', 5: 'upload_started', 6: 'error_recovery',
+  7: 'full_sleep',
+};
+const DETAIL_WIRE_SIZE = 176;
+
+function u64LeHex(bytes: Uint8Array): string {
+  return Buffer.from(bytes).reverse().toString('hex').padStart(16, '0');
+}
+
+export function diagnosticEventIdCommand(eventId: string): Buffer {
+  if (!/^[0-9a-f]{16}$/.test(eventId)) {
+    throw new Error('Diagnostic event_id must be 16 lowercase hex characters');
+  }
+  return Buffer.concat([
+    Buffer.from([0x11]),
+    Buffer.from(eventId, 'hex').reverse(),
+  ]);
+}
+
+type PartialEvent = Omit<DeviceDiagnosticEvent, 'signature' | 'firmware_build_id' |
+  'subsystem' | 'state_before_event'> & {
+    signature?: string;
+    firmware_build_id?: string;
+    subsystem?: string;
+    state_before_event?: string;
+  };
+
+interface DetailAssembly {
+  buffer: Buffer;
+  received: number;
+}
+
+function normalizedAddress(value: number): string | undefined {
+  if (value === 0) return undefined;
+  const region = (value & 0x80000000) !== 0
+    ? 'sdram'
+    : (value & 0x40000000) !== 0 ? 'ram' : 'rom';
+  const offset = (value & 0x3fffffff).toString(16).padStart(8, '0');
+  return `${region}:${offset}`;
+}
+
+function fixedHex32(value: number): string {
+  return value.toString(16).padStart(8, '0');
+}
+
+function decodeDetail(bytes: Buffer): Pick<DeviceDiagnosticEvent,
+  'firmware_build_id' | 'subsystem' | 'state_before_event' | 'report'> {
+  if (bytes.length !== DETAIL_WIRE_SIZE || bytes[0] !== 1) {
+    throw new Error('Unsupported diagnostic detail payload');
+  }
+  const hasReport = (bytes[1] & 1) !== 0;
+  const firmwareBuildId = Buffer.from(bytes.subarray(2, 14)).toString('ascii');
+  if (!/^[0-9a-f]{12}$/.test(firmwareBuildId)) {
+    throw new Error('Invalid diagnostic firmware build id');
+  }
+  const common = {
+    firmware_build_id: firmwareBuildId,
+    subsystem: SUBSYSTEMS[bytes[14]] ?? 'system',
+    state_before_event: STATES[bytes[15]] ?? 'unknown',
+  };
+  if (!hasReport) return common;
+
+  const pcCount = Math.min(bytes[17], 6);
+  const breadcrumbCount = Math.min(bytes[18], 8);
+  const runtimeMask = bytes[19];
+  const pcTrace: string[] = [];
+  for (let index = 0; index < pcCount; index++) {
+    const address = normalizedAddress(bytes.readUInt32LE(48 + index * 4));
+    if (address) pcTrace.push(address);
+  }
+  const task = Buffer.from(bytes.subarray(80, 96)).toString('ascii').replace(/\0.*$/, '');
+  const breadcrumbs = [];
+  for (let index = 0; index < breadcrumbCount; index++) {
+    const offset = 96 + index * 10;
+    breadcrumbs.push({
+      delta_ms: bytes.readInt32LE(offset),
+      code: BREADCRUMBS[bytes.readUInt16LE(offset + 4)] ?? 'state_changed',
+      arg0: bytes.readInt32LE(offset + 6),
+    });
+  }
+  const reti = normalizedAddress(bytes.readUInt32LE(40));
+  const rets = normalizedAddress(bytes.readUInt32LE(44));
+  return {
+    ...common,
+    report: {
+      fault: {
+        cpu_id: bytes[16],
+        cpu_emu: fixedHex32(bytes.readUInt32LE(20)),
+        core_emu: fixedHex32(bytes.readUInt32LE(24)),
+        hsb_emu: fixedHex32(bytes.readUInt32LE(28)),
+        audio_emu: fixedHex32(bytes.readUInt32LE(32)),
+        wireless_emu: fixedHex32(bytes.readUInt32LE(36)),
+      },
+      execution: {
+        ...(task ? { task } : {}),
+        ...(reti ? { reti } : {}),
+        ...(rets ? { rets } : {}),
+        pc_trace: pcTrace,
+      },
+      ...((runtimeMask & 3) !== 0 ? {
+        runtime: {
+          ...((runtimeMask & 1) !== 0
+            ? { heap_free_bytes: bytes.readUInt32LE(72) } : {}),
+          ...((runtimeMask & 2) !== 0
+            ? { task_stack_remaining_bytes: bytes.readUInt32LE(76) } : {}),
+        },
+      } : {}),
+      ...(breadcrumbs.length ? { breadcrumbs } : {}),
+    },
+  };
+}
+
+export class DeviceDiagnosticsDecoder {
+  private events = new Map<number, PartialEvent>();
+  private details = new Map<number, DetailAssembly>();
+
+  push(packet: Buffer): DeviceDiagnosticsBatch | null {
+    if (packet.length === 17 && packet[0] === DEVICE_DIAGNOSTICS_EVT_META) {
+      const type = EVENT_TYPES[packet[2]];
+      if (!type) return null;
+      this.events.set(packet[1], {
+        event_id: u64LeHex(packet.subarray(9, 17)),
+        event_type: type,
+        reason_code: REASONS[packet.readUInt16LE(3)] ?? 'unknown_cpu_exception',
+        uptime_ms: packet.readUInt32LE(5),
+      });
+      return null;
+    }
+    if (packet.length === 10 && packet[0] === DEVICE_DIAGNOSTICS_EVT_SIGNATURE) {
+      const event = this.events.get(packet[1]);
+      if (event) event.signature = u64LeHex(packet.subarray(2, 10));
+      return null;
+    }
+    if (packet.length >= 6 && packet.length <= 20 &&
+        packet[0] === DEVICE_DIAGNOSTICS_EVT_DETAIL) {
+      const index = packet[1];
+      const offset = packet.readUInt16LE(2);
+      const total = packet.readUInt16LE(4);
+      if (total !== DETAIL_WIRE_SIZE || offset + packet.length - 6 > total) {
+        this.reset();
+        throw new Error('Invalid diagnostic detail chunk');
+      }
+      let detail = this.details.get(index);
+      if (offset === 0) {
+        if (detail) {
+          this.reset();
+          throw new Error(`Duplicate diagnostic detail at index ${index}`);
+        }
+        detail = { buffer: Buffer.alloc(total), received: 0 };
+        this.details.set(index, detail);
+      }
+      if (!detail || detail.received !== offset) {
+        this.reset();
+        throw new Error(`Out-of-order diagnostic detail at index ${index}`);
+      }
+      packet.copy(detail.buffer, offset, 6);
+      detail.received += packet.length - 6;
+      if (detail.received === total) {
+        const event = this.events.get(index);
+        if (!event) {
+          this.reset();
+          throw new Error(`Diagnostic detail without metadata at index ${index}`);
+        }
+        try {
+          Object.assign(event, decodeDetail(detail.buffer));
+        } catch (error) {
+          this.reset();
+          throw error;
+        }
+      }
+      return null;
+    }
+    if (packet.length === 2 && packet[0] === DEVICE_DIAGNOSTICS_EVT_END) {
+      const expected = packet[1];
+      const events: DeviceDiagnosticEvent[] = [];
+      for (let index = 0; index < expected; index++) {
+        const event = this.events.get(index);
+        if (!event?.signature || !event.firmware_build_id ||
+            !event.subsystem || !event.state_before_event ||
+            this.details.get(index)?.received !== DETAIL_WIRE_SIZE) {
+          this.reset();
+          throw new Error(`Incomplete diagnostic event at index ${index}`);
+        }
+        events.push(event as DeviceDiagnosticEvent);
+      }
+      const batch: DeviceDiagnosticsBatch = {
+        schema_version: 1,
+        events,
+      };
+      this.reset();
+      return batch;
+    }
+    return null;
+  }
+
+  reset(): void {
+    this.events.clear();
+    this.details.clear();
+  }
+}