@scalebun/react-native 1.0.3 → 1.1.0

package/src/public/ScaleBunFacade.ts

@@ -13,10 +13,14 @@ import { noThrow, safeAsync } from '../core/lifecycle/crashSafe';
 import { logger } from '../core/logger/internalLogger';
 import { createEnvelope } from '../pipeline/envelope/envelope';
 import { generateEventId } from '../features/replay/core/ids/sessionId';
+import { buildBugReportPayload } from '../features/bugreport/buildPayload';
+import type { BugSubmitResult } from '../features/bugreport/BugReportFeature';
+import { BugReportFeature } from '../features/bugreport/BugReportFeature';
 import { PersistentQueue } from '../pipeline/queue/persistentQueue';
 import { MemoryBackend, createStorageBackend } from '../storage/StorageBackend';
 import { HttpClient } from '../transport/http/httpClient';
 import { getDeviceId } from '../core/id/deviceId';
+import { mergeDeviceContext } from '../core/context/device';
 import { coreContainer } from '../core/di/container';
 import { flushQueue } from '../pipeline/queue/flushQueue';
 import {
@@ -247,6 +251,13 @@ class ScaleBunFacade {
                 // Continue — debug connection is independent of backend API
             }
 
+            // OTA from init config. Without this the whole `ota` config block was
+            // inert: `otaOrchestrator.init()` was reachable only by importing the
+            // orchestrator directly, so an app that followed the documented
+            // `ota: { enabled: true }` path silently got no updates AND no
+            // signature enforcement (sync() gates on the flag init() sets).
+            this._maybeStartOta(rawConfig);
+
             // Auto debug connection from init config — runs regardless of backend status
             const debugConfig = (rawConfig?.desktopDebug ?? rawConfig?.debug) as DebugConnectionConfig | undefined;
             if (debugConfig) {
@@ -260,6 +271,44 @@ class ScaleBunFacade {
         }
     }
 
+    /**
+     * Boot the OTA orchestrator when the init config asks for it.
+     *
+     * `publicSigningKey` is honoured here so signature enforcement is reachable
+     * from configuration alone. The SDK ships no ed25519 implementation, so a
+     * host that pins a key must also supply `ota.verifySignature`; pinning a key
+     * without a verifier is fail-CLOSED by design (signature.ts) — an update
+     * that cannot be verified is not installed. We say that out loud rather than
+     * letting the app discover it as a silent no-update condition.
+     */
+    private _maybeStartOta(rawConfig: any): void {
+        const ota = rawConfig?.ota;
+        if (!ota?.enabled) return;
+        try {
+            // Required lazily: hosts that never enable OTA should not pay for the
+            // module (or touch the native spec) at import time.
+            // eslint-disable-next-line @typescript-eslint/no-var-requires
+            const { otaOrchestrator } = require('../features/ota/OtaOrchestrator');
+            const publicKey = ota.publicSigningKey;
+            const verifier = ota.verifySignature;
+            if (publicKey && typeof verifier !== 'function') {
+                logger.warn(
+                    '[ScaleBun] ota.publicSigningKey is set but ota.verifySignature is not a function. ' +
+                        'Signature checking is fail-closed: updates will be REJECTED until a verifier is supplied.',
+                );
+            }
+            otaOrchestrator.init({
+                ...(publicKey ? { signature: { publicKey, verifier } } : {}),
+                ...(typeof ota.healthyTimeoutMs === 'number'
+                    ? { healthyTimeoutMs: ota.healthyTimeoutMs }
+                    : {}),
+            });
+            logger.info('[ScaleBun] OTA enabled from init config.');
+        } catch (err: any) {
+            logger.warn(`[ScaleBun] OTA init failed: ${err?.message ?? err}`);
+        }
+    }
+
     private _autoEnableDebug(debugConfig: DebugConnectionConfig): void {
         try {
             const dbgConfig = buildDebugConfigFromInitConfig(debugConfig);
@@ -278,7 +327,9 @@ class ScaleBunFacade {
             const appId = rawConfig?.appId;
             const enabled = rawConfig?.eventTracking !== false;
             const clientKey = this._clientKey ?? rawConfig?.clientKey;
-            const apiBaseUrl = this._apiBaseUrl ?? rawConfig?.apiBaseUrl;
+            // apiBaseUrl is LOCKED — use only the bootstrapped value, never fall back to raw
+            // integrator input, so the event-tracker/SKAdNetwork lane can't be repointed either.
+            const apiBaseUrl = this._apiBaseUrl;
             if (!enabled || !appId || !clientKey || !apiBaseUrl) {
                 if (enabled && !appId) {
                     logger.info('[ScaleBun] Envelope event tracking disabled — no appId in init config.');
@@ -307,7 +358,16 @@ class ScaleBunFacade {
                 automaticEventTracking:
                     rawConfig?.automaticEventTracking === true,
                 flushIntervalMs: rawConfig?.flushIntervalMs,
-                context: rawConfig?.context,
+                /**
+                 * DETECTED, not configured.
+                 *
+                 * This was `rawConfig?.context` — whatever the app typed. Production carries
+                 * `device_model: "android"` and `manufacturer: "android"` from a hand-written
+                 * literal, while the replay lane was reading the real values off the native bridge
+                 * the whole time. The SDK knows the device; the integrator is guessing at it.
+                 * Everything outside the detected keys is still theirs.
+                 */
+                context: mergeDeviceContext(rawConfig?.context),
                 // Use the same foreground id as replay/journey capture. The
                 // callback is resolved per event because the session subsystem
                 // may start after this tracker is constructed.
@@ -597,6 +657,125 @@ class ScaleBunFacade {
         return null;
     }
 
+    // ─── Bug reports (F-BUG) ────────────────────────────────────────────
+
+    /**
+     * Thin feature object; the facade owns the HTTP, mirroring the web SDK split.
+     * Its only job here is raising the 'report' capture signal so replay flushes.
+     */
+    private readonly _bugReport = new BugReportFeature();
+
+    /**
+     * Submit a bug report against the CURRENT session.
+     *
+     * Mirrors the web SDK's `reportBugDetailed` ordering, which is load-bearing rather than
+     * incidental:
+     *
+     *   1. resolve the session   — a report with no session cannot be joined to its evidence
+     *   2. signal 'report'       — replay flushes its buffer so the report has visual context
+     *   3. snapshot the anchor   — BEFORE the POST. A flush asks the recorder to deliver pending
+     *                              bytes; it cannot retroactively manufacture a frame, so an absent
+     *                              coordinate must stay absent rather than becoming a misleading
+     *                              "start of session" link in the dashboard
+     *   4. build + POST          — bounds enforced by buildBugReportPayload against the server DTO
+     *
+     * Returns the report id, or `{ e }` naming which branch failed — 'init' (SDK not configured)
+     * reads differently from 'send' (network), and that difference is what tells an integrator
+     * whether to check their setup or their connection. It never throws: this is called from a UI
+     * the host app renders, usually from a user gesture, and an exception escaping into a React
+     * Native render tree is a redbox shown to the customer's user over a report they were sending us.
+     */
+    public async reportBugDetailed(input: {
+        message: string;
+        title?: string;
+        email?: string;
+        clientReportId?: string;
+    }): Promise<BugSubmitResult> {
+        if (!input || !input.message || input.message.trim().length === 0) {
+            logger.warn('[ScaleBun] reportBug: a message is required');
+            return { e: 'empty' };
+        }
+        if (!this._clientKey || !this._apiBaseUrl) {
+            logger.warn('[ScaleBun] reportBug: SDK is not configured (clientKey/apiBaseUrl)');
+            return { e: 'init' };
+        }
+
+        const sessionId = this.getActiveSessionId();
+        if (!sessionId) {
+            // No session means no row to attach to, and the ingestion route is session-scoped.
+            logger.warn('[ScaleBun] reportBug: no active session');
+            return { e: 'init' };
+        }
+
+        try {
+            // Flush replay into the session BEFORE reading the anchor below.
+            this._bugReport.signalReport();
+
+            const coord = this._replayCoord();
+            const payload = buildBugReportPayload(input, this._recentBreadcrumbs(), {
+                replayCoord: coord,
+                timestamp: Date.now(),
+            });
+
+            const res = await fetch(
+                `${this._apiBaseUrl}/ingestion/sessions/${sessionId}/bug-reports`,
+                {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        'x-scalebun-client-key': this._clientKey,
+                    },
+                    body: JSON.stringify(payload),
+                },
+            );
+            if (!res.ok) {
+                logger.warn('[ScaleBun] reportBug: server rejected the report', res.status);
+                return { e: 'send' };
+            }
+            const body = await res.json().catch(() => null);
+            return body?.id ?? { e: 'send' };
+        } catch (err: any) {
+            logger.warn('[ScaleBun] reportBug failed:', err?.message);
+            return { e: 'send' };
+        }
+    }
+
+    /**
+     * The replay coordinate at submit time, or null.
+     *
+     * Deliberately returns null rather than a zeroed coordinate when replay is disabled, paused, or
+     * has not produced a frame yet — see the anchor note on reportBug.
+     */
+    /**
+     * The replay coordinate at submit time.
+     *
+     * ALWAYS null today, deliberately and visibly.
+     *
+     * The web SDK reads this from its recorder, but the RN replay subsystem exposes no sequence or
+     * segment accessor on its public API (features/replay/public/api.ts) -- there is currently no
+     * supported way to ask it where playback is. Probing for it through an `any` cast would compile,
+     * miss, and leave every report anchor-less while looking wired: the same defect as the existing
+     * reportBug(), which emits an analytics event and looks like it files a report.
+     *
+     * Returning null keeps the payload HONEST -- buildBugReportPayload omits replaySeq entirely, so
+     * the dashboard shows no anchor rather than a false one pointing at the start of the session.
+     * To finish this: expose the current seq + segment id from the replay recorder, then read them
+     * here. The payload builder and its contract tests already handle a real coordinate, including
+     * a genuine seq of 0.
+     */
+    private _replayCoord(): { seq?: number | null; segmentId?: string | null } | null {
+        return null;
+    }
+    /** Recent console breadcrumbs for quick triage. The full set already travels with the session. */
+    private _recentBreadcrumbs(): readonly unknown[] {
+        try {
+            const f = (this as any)._loggerFeature ?? (this as any)._consoleFeature;
+            return f?.getRecent?.() ?? [];
+        } catch {
+            return [];
+        }
+    }
+
     // ─── Engage ─────────────────────────────────────────────────────────
 
     /**
@@ -1131,6 +1310,23 @@ class ScaleBunFacade {
 
     /** Report a bug (convenience wrapper over track) */
     public reportBug(description: string, metadata?: Record<string, unknown>) {
+        // D11: this used to be ONLY `track('$bug_report')` — an analytics event
+        // with zero consumers (no mapper, no handler, no BugReport row), so
+        // /diagnose/bug-reports stayed empty forever for RN apps while the web
+        // SDK used the real ingest. Route to the same endpoint the web SDK
+        // uses; the analytics event is kept as a breadcrumb, not the delivery.
+        try {
+            const transport = SessionManager.getExistingInstance()?.getBackendTransport();
+            transport?.submitBugReport({
+                message: description,
+                title:
+                    typeof metadata?.title === 'string' ? (metadata.title as string) : undefined,
+                email:
+                    typeof metadata?.email === 'string' ? (metadata.email as string) : undefined,
+            });
+        } catch {
+            /* delivery is best-effort; the track below still records intent */
+        }
         return this.track('$bug_report', { description, ...metadata });
     }
 

package/src/public/types.ts

@@ -78,14 +78,28 @@ export interface ScaleBunInitConfig {
     /** Publishable API key from dashboard */
     publishableKey: string;
     /**
-     * Backend API base URL. Optional — defaults to the ScaleBun cloud.
-     * Override only for staging or a self-hosted backend.
+     * @deprecated The endpoint is LOCKED to the ScaleBun cloud. Any value passed here is accepted
+     * (for backward compatibility) but ignored — the bootstrapper always uses the fixed
+     * `DEFAULT_API_BASE_URL`. To target a different backend, change that constant at build time.
      */
     apiBaseUrl?: string;
     /** @deprecated Use desktopDebug instead */
     debug?: boolean;
-    /** Enable session replay capture. Default: true */
+    /** Enable session replay capture (feature on/off). Default: true */
     sessionReplay?: boolean;
+    /**
+     * Session-replay capture options (SaaS mode).
+     * - `record` (default **true**): auto-start frame recording at cold launch so replays appear out
+     *   of the box. Set `false` for events-only sessions — you can still record on demand with
+     *   `ScaleBun.startSession()`.
+     * - `captureMode` / `intervalMs` / `quality`: tune capture cadence.
+     */
+    replay?: {
+        record?: boolean;
+        captureMode?: 'navigation' | 'interactions' | 'frequency';
+        intervalMs?: number;
+        quality?: 'high' | 'normal' | 'low' | 'grayscale';
+    };
     /** Event flush interval in ms. Default: 5000 */
     flushIntervalMs?: number;
     /** Max events per flush batch. Default: 1000 */
@@ -234,7 +248,6 @@ export interface ExportResult {
  * await ScaleBun.init({
  *   projectId: 'proj_xxx',
  *   publishableKey: 'pk_xxx',
- *   apiBaseUrl: 'https://api.scalebun.com',
  * });
  * ```
  *
@@ -243,7 +256,6 @@ export interface ExportResult {
  * await ScaleBun.init({
  *   projectId: 'proj_xxx',
  *   publishableKey: 'pk_xxx',
- *   apiBaseUrl: 'https://api.scalebun.com',
  *   debug: true,
  * });
  * ```
@@ -254,8 +266,9 @@ export interface SimplifiedInitConfig {
     /** Publishable API key from dashboard */
     publishableKey: string;
     /**
-     * Backend API base URL. Optional — defaults to the ScaleBun cloud.
-     * Override only for staging or a self-hosted backend.
+     * @deprecated The endpoint is LOCKED to the ScaleBun cloud. Any value passed here is accepted
+     * (for backward compatibility) but ignored — the bootstrapper always uses the fixed
+     * `DEFAULT_API_BASE_URL`. To target a different backend, change that constant at build time.
      */
     apiBaseUrl?: string;
 
@@ -271,9 +284,23 @@ export interface SimplifiedInitConfig {
     /** @deprecated Use desktopDebug instead. */
     debug?: DebugConnectionConfig;
 
-    /** Enable session replay capture. Default: true */
+    /** Enable session replay capture (feature on/off). Default: true */
     sessionReplay?: boolean;
 
+    /**
+     * Session-replay capture options (SaaS mode).
+     * - `record` (default **true**): auto-start frame recording at cold launch so replays appear out
+     *   of the box. Set `false` for events-only sessions — you can still record on demand with
+     *   `ScaleBun.startSession()`.
+     * - `captureMode` / `intervalMs` / `quality`: tune capture cadence.
+     */
+    replay?: {
+        record?: boolean;
+        captureMode?: 'navigation' | 'interactions' | 'frequency';
+        intervalMs?: number;
+        quality?: 'high' | 'normal' | 'low' | 'grayscale';
+    };
+
     /** SDK-wide privacy settings */
     privacy?: PrivacyConfig;
 

package/src/specs/NativeScaleBunCrash.ts

@@ -23,8 +23,24 @@ export interface Spec extends TurboModule {
   /** DEV/TEST only: crash the process so the next launch can drain it. */
   crashNow(): Promise<boolean>;
 
+  /**
+   * Record which session is live so a crash can name it.
+   *
+   * Called once per session. Native writes it to crash-safe storage BEFORE any crash can happen —
+   * a fatal handler cannot call back into JS to ask.
+   */
+  setActiveSessionId(sessionId: string): Promise<boolean>;
+
   /** Return the previous run's crash record (or null), then clear it. */
   drainPendingCrash(): Promise<Object>;
+
+  /**
+   * Delete a delivered crash by its stable id.
+   *
+   * Called ONLY after the backend has accepted it. The read is non-destructive precisely so this
+   * can be the moment of deletion — a failed upload must leave the durable copy in place.
+   */
+  clearPendingCrash(crashId: string): Promise<boolean>;
 }
 
 /**