@bota.dev/web-app-sdk 2.0.0-beta.0

package/dist/logManager.d.ts

@@ -0,0 +1,24 @@
+import type { CoreBridge } from './core.ts';
+import { DeviceManager } from './deviceManager.ts';
+import type { DeviceLogLine, DeviceLogSubscription } from './models.ts';
+import { BrowserWorkflowRuntime } from './workflowRuntime.ts';
+interface LogManagerOptions {
+    core: CoreBridge;
+    runtime: BrowserWorkflowRuntime;
+    devices: DeviceManager;
+}
+export declare class LogManager {
+    private readonly core;
+    private readonly runtime;
+    private readonly devices;
+    private activeOwner;
+    private destroyed;
+    private destroyPromise;
+    constructor(options: LogManagerOptions);
+    subscribe(listener: (line: DeviceLogLine) => void): Promise<DeviceLogSubscription>;
+    destroy(): Promise<void>;
+    private deliver;
+    private closeOwner;
+    private finishOwner;
+}
+export {};

package/dist/logManager.js

@@ -0,0 +1,205 @@
+import { verifyActiveDeviceSerial, } from "./deviceManager.js";
+import { BotaSDKError, normalizeCoreError } from "./errors.js";
+import { BOTA_DIAGNOSTICS_SERVICE, DEVICE_LOG_DATA_CHARACTERISTIC, } from "./gatt.js";
+import { createBrowserPersistenceHost, } from "./workflowRuntime.js";
+export class LogManager {
+    core;
+    runtime;
+    devices;
+    activeOwner = null;
+    destroyed = false;
+    destroyPromise = null;
+    constructor(options) {
+        this.core = options.core;
+        this.runtime = options.runtime;
+        this.devices = options.devices;
+    }
+    async subscribe(listener) {
+        if (this.destroyed) {
+            throw new BotaSDKError('cancelled', 'read_device_logs');
+        }
+        if (typeof listener !== 'function') {
+            throw new BotaSDKError('invalid_input', 'read_device_logs');
+        }
+        if (this.activeOwner) {
+            throw new BotaSDKError('operation_in_progress', 'read_device_logs');
+        }
+        const connected = await verifyActiveDeviceSerial(this.devices, 'read_device_logs');
+        const device = this.runtime.connectedDeviceHandle;
+        if (!device || connected.id !== device.id) {
+            throw new BotaSDKError('device_disconnected', 'read_device_logs');
+        }
+        let lease;
+        try {
+            lease = this.runtime.claimCharacteristicLease('read_device_logs', device, BOTA_DIAGNOSTICS_SERVICE, DEVICE_LOG_DATA_CHARACTERISTIC);
+        }
+        catch (error) {
+            throw managerError(error);
+        }
+        const cancellationId = randomBytes(16);
+        const operationId = `read_device_logs:${bytesHex(cancellationId)}`;
+        const owner = {
+            operationId,
+            cancellationId,
+            lease,
+            listener,
+            ready: deferred(),
+            outcome: Promise.resolve({
+                kind: 'failed',
+                error: new BotaSDKError('internal_error', 'read_device_logs'),
+            }),
+            settled: Promise.resolve(),
+            closing: false,
+            closed: false,
+            terminalError: null,
+            closePromise: null,
+        };
+        this.activeOwner = owner;
+        const workflow = this.runtime.run(operationId, cancellationId, () => this.core.startDeviceLogs({
+            serialNumber: connected.serialNumber,
+            cancellationId: cancellationId.slice(),
+        }), { persistence: createBrowserPersistenceHost(null) }, {
+            onNotification: (notification) => this.deliver(owner, notification),
+            onRunning: () => owner.ready.resolve(undefined),
+        });
+        owner.outcome = workflow.then((result) => ({ kind: 'completed', result }), (error) => ({ kind: 'failed', error: managerError(error) }));
+        owner.settled = owner.outcome.then((outcome) => {
+            this.finishOwner(owner, outcome);
+        });
+        try {
+            await Promise.race([
+                owner.ready.promise,
+                owner.outcome.then((outcome) => {
+                    if (outcome.kind === 'failed')
+                        throw outcome.error;
+                    throw unexpectedStreamEnd();
+                }),
+            ]);
+            if (this.destroyed || owner.closing || owner.closed) {
+                await this.closeOwner(owner);
+                throw owner.terminalError
+                    ?? new BotaSDKError('cancelled', 'read_device_logs');
+            }
+            return {
+                remove: async () => await this.closeOwner(owner),
+            };
+        }
+        catch (error) {
+            if (!owner.closed) {
+                await this.closeOwner(owner).catch(() => undefined);
+            }
+            throw managerError(error);
+        }
+    }
+    destroy() {
+        if (this.destroyPromise)
+            return this.destroyPromise;
+        this.destroyed = true;
+        const owner = this.activeOwner;
+        this.destroyPromise = owner
+            ? this.closeOwner(owner).catch(() => undefined)
+            : Promise.resolve();
+        return this.destroyPromise;
+    }
+    deliver(owner, notification) {
+        if (notification.kind !== 'device_log'
+            || owner.closing
+            || owner.closed
+            || this.activeOwner !== owner)
+            return;
+        if (typeof notification.message !== 'string'
+            || typeof notification.isBacklog !== 'boolean') {
+            owner.terminalError ??= new BotaSDKError('protocol_error', 'read_device_logs');
+            void this.closeOwner(owner).catch(() => undefined);
+            return;
+        }
+        const listener = owner.listener;
+        if (!listener)
+            return;
+        try {
+            const completion = listener({
+                message: notification.message,
+                isBacklog: notification.isBacklog,
+            });
+            if (isPromiseLike(completion)) {
+                void Promise.resolve(completion).catch(() => {
+                    void this.closeOwner(owner).catch(() => undefined);
+                });
+            }
+        }
+        catch {
+            void this.closeOwner(owner).catch(() => undefined);
+        }
+    }
+    closeOwner(owner) {
+        if (owner.closePromise)
+            return owner.closePromise;
+        owner.closing = true;
+        owner.listener = null;
+        owner.closePromise = (async () => {
+            let cancellationError = null;
+            if (!owner.closed) {
+                try {
+                    await this.runtime.cancel(owner.operationId);
+                }
+                catch (error) {
+                    cancellationError = managerError(error);
+                }
+                await owner.settled;
+            }
+            if (owner.terminalError)
+                throw owner.terminalError;
+            if (cancellationError)
+                throw cancellationError;
+        })();
+        return owner.closePromise;
+    }
+    finishOwner(owner, outcome) {
+        if (owner.closed)
+            return;
+        owner.closed = true;
+        owner.listener = null;
+        if (!owner.closing) {
+            owner.terminalError = outcome.kind === 'failed'
+                ? outcome.error
+                : unexpectedStreamEnd();
+        }
+        else if (outcome.kind === 'failed'
+            && outcome.error.code !== 'cancelled'
+            && owner.terminalError === null) {
+            owner.terminalError = outcome.error;
+        }
+        owner.cancellationId.fill(0);
+        owner.lease.release();
+        if (this.activeOwner === owner)
+            this.activeOwner = null;
+    }
+}
+function unexpectedStreamEnd() {
+    return new BotaSDKError('connection_failed', 'read_device_logs', {
+        retryable: true,
+    });
+}
+function managerError(error) {
+    return normalizeCoreError(error, 'read_device_logs');
+}
+function randomBytes(length) {
+    const value = new Uint8Array(length);
+    globalThis.crypto.getRandomValues(value);
+    return value;
+}
+function bytesHex(value) {
+    return Array.from(value, (byte) => byte.toString(16).padStart(2, '0')).join('');
+}
+function deferred() {
+    let resolve;
+    const promise = new Promise((resolvePromise) => {
+        resolve = resolvePromise;
+    });
+    return { promise, resolve };
+}
+function isPromiseLike(value) {
+    return typeof value === 'object'
+        && value !== null
+        && typeof value.then === 'function';
+}

package/dist/models.d.ts

@@ -0,0 +1,217 @@
+export type RecordingJournalPhase = 'prepared' | 'transferring' | 'staged' | 'uploading' | 'cloud_completed' | 'confirmed';
+export type DeviceState = 'idle' | 'recording' | 'syncing' | 'uploading' | 'charging' | 'low_battery' | 'storage_full' | 'error' | 'unknown';
+export interface DeviceFlags {
+    charging: boolean;
+    lowBattery: boolean;
+    storageFull: boolean;
+    wifiConnected: boolean;
+    lteConnected: boolean;
+    syncActive: boolean;
+}
+export interface ModemInfo {
+    imei: string | null;
+    iccid: string | null;
+    operator: string | null;
+    rat: string | null;
+    band: string | null;
+    apn: string | null;
+    simStatus: string | null;
+    csq: number | null;
+    ipAddress: string | null;
+    voltageMillivolts: number | null;
+    firmware: string | null;
+    roaming: boolean | null;
+}
+export interface DeviceStatus {
+    batteryPercent: number;
+    batteryMillivolts: number | null;
+    storageTotalMb: number;
+    storageUsedMb: number;
+    state: DeviceState;
+    stateRaw?: number;
+    pendingRecordings: number;
+    lastTimeSyncTimestamp: number;
+    flags: DeviceFlags;
+    lteStatusRaw: number;
+    lteSignalQuality: number | null;
+    wifiStatusRaw: number | null;
+    modemInfo: ModemInfo | null;
+}
+export interface EncryptedUploadV2Capabilities {
+    flags: number;
+    maximumSignedBlobBytes: number;
+    maximumManifestBytes: number;
+    maximumDataPayloadBytes: number;
+    maximumWindowPackets: number;
+    durableCheckpointIntervalBlocks: number;
+    maximumMissingSequences: number;
+}
+export interface ConnectedDevice {
+    id: string;
+    name: string | null;
+    serialNumber: string;
+}
+export interface DeviceSnapshot {
+    identity: {
+        serialNumber: string;
+        modelNumber: string | null;
+        hardwareRevision: string | null;
+        firmwareRevision: string | null;
+    };
+    status: DeviceStatus;
+    capabilities: {
+        encryptedUploadV2: EncryptedUploadV2Capabilities | null;
+    };
+    capturedAt: Date;
+}
+export interface ConnectOptions {
+    expectedSerialNumber: string;
+}
+export interface ReconnectOptions {
+    expectedSerialNumber: string;
+}
+export interface ProvisionRequest {
+    attemptId: string;
+    signal?: AbortSignal;
+}
+export interface DeprovisionRequest {
+    grant: Uint8Array;
+    signal?: AbortSignal;
+}
+export interface DeprovisionResult {
+    success: boolean;
+    error?: 'invalid_token' | 'storage_error' | 'chunk_error' | 'already_paired' | 'unknown';
+    errorRaw?: number;
+}
+export interface DeviceConnectionSettings {
+    enabledConnections: {
+        wifi: boolean;
+        cellular: boolean;
+    };
+    heartbeatEnabledConnections: {
+        wifi: boolean;
+        cellular: boolean;
+    };
+    uploadNetworkPreference: Array<'wifi' | 'ble' | 'cellular'>;
+    powerManagement: {
+        cellularIdleTimeoutSeconds: number;
+        wifiIdleTimeoutSeconds: number;
+    };
+    streamingEnabled: boolean;
+    streamingFlushIntervalSeconds: number;
+}
+export interface WiFiCredentials {
+    ssid: string;
+    password: string;
+}
+export interface WiFiScanNetwork {
+    ssid: string;
+    quality: number;
+    isCurrent: boolean;
+    isOpen: boolean;
+}
+export interface WiFiScanResult {
+    networks: WiFiScanNetwork[];
+    currentSsid: string | null;
+}
+export interface WiFiStatusInfo {
+    status: 'idle' | 'connecting' | 'connected' | 'failed' | 'disconnected' | 'unknown';
+    statusRaw: number;
+    signalStrength?: number;
+    ssid?: string;
+    lastError?: string;
+}
+export type WiFiConfigResult = {
+    success: true;
+} | {
+    success: false;
+    error: 'invalid_grant' | 'grant_expired' | 'decryption_error' | 'storage_error' | 'unknown';
+    errorRaw?: number;
+};
+export interface WiFiStatusSubscription {
+    remove(): Promise<void>;
+}
+export interface DeviceLogLine {
+    message: string;
+    isBacklog: boolean;
+}
+export interface DeviceLogSubscription {
+    remove(): Promise<void>;
+}
+export interface RecordingControlRequest {
+    authorityId: string;
+    operationId?: string;
+    signal?: AbortSignal;
+}
+export type RecordingControlResult = {
+    success: true;
+} | {
+    success: false;
+    error: 'already_recording' | 'not_recording' | 'invalid_grant' | 'invalid_state' | 'invalid_response' | 'unknown_error';
+    errorRaw?: number;
+};
+export interface BrowserCapabilities {
+    readonly bluetooth: boolean;
+    readonly authorizedDeviceReconnect: boolean;
+    readonly durableStorage: boolean;
+    readonly largeRecordingSync: boolean;
+    readonly firmwareUpdate: boolean;
+}
+export interface FirmwareImageDescriptor {
+    imageId: string;
+    version: string;
+    sizeBytes: number;
+    crc32: number;
+    sha256Hex: string;
+}
+export interface FirmwareUpdateOptions {
+    operationId?: string;
+    signal?: AbortSignal;
+    onProgress?: (progress: FirmwareUpdateProgress) => void;
+}
+export interface FirmwareUpdateProgress {
+    phase: 'downloading' | 'awaiting_device' | 'transferring' | 'verifying' | 'rebooting' | 'reconnecting' | 'complete';
+    completedBytes: bigint;
+    totalBytes: bigint;
+}
+export interface DeviceRecording {
+    uuid: string;
+    startedAtTimestampSeconds: number;
+    durationMilliseconds: bigint;
+    fileSizeBytes: bigint;
+    codec: 'pcm_16k' | 'pcm_8k' | 'opus_16k' | 'opus_8k' | 'unknown';
+    codecRaw?: number;
+    encrypted: boolean;
+    encryptedUploadV2: {
+        generation: number;
+        storageFormat: number;
+        plaintextLength: bigint;
+        ciphertextLength: bigint;
+        ciphertextSha256: Uint8Array;
+    } | null;
+}
+export interface RecordingSyncProgress {
+    phase: RecordingJournalPhase;
+    completedBytes: bigint;
+    totalBytes: bigint;
+}
+export interface RecordingSyncResult {
+    operationId: string;
+    recordingUuid: string;
+    profile: 'legacy' | 'encrypted_upload_v2';
+    cloudCompletionId: string;
+}
+export interface RecordingSyncOptions {
+    profile: 'legacy' | 'encrypted_upload_v2';
+    operationId?: string;
+    signal?: AbortSignal;
+    onProgress?: (progress: RecordingSyncProgress) => void;
+}
+export interface RecordingJournalSummary {
+    operationId: string;
+    serialNumber: string;
+    recordingUuid: string;
+    profile: 'legacy' | 'encrypted_upload_v2';
+    phase: RecordingJournalPhase;
+    updatedAtEpochMs: number;
+}

package/dist/models.js

@@ -0,0 +1 @@
+export {};

package/dist/opfsBlobStore.d.ts

@@ -0,0 +1,12 @@
+import type { CoreIntegrityHasher } from './core.ts';
+import type { BrowserBlobHandle } from './storage.ts';
+export declare class OpfsBlobStore {
+    private readonly root;
+    private readonly createIntegrityHasher;
+    private readonly namespaceDirectoryName;
+    constructor(namespace: string, root: FileSystemDirectoryHandle, createIntegrityHasher: () => CoreIntegrityHasher);
+    open(blobId: string): Promise<BrowserBlobHandle>;
+    clear(): Promise<void>;
+    private namespaceDirectory;
+    private hashName;
+}