@scalebun/react-native 1.0.4 → 1.2.0

package/src/bootstrap/SDKBootstrapper.ts

@@ -114,7 +114,7 @@ export class SDKBootstrapper {
         // These are flushed immediately so crash-time events are not lost.
         const leftovers = persistentQueue.drainLeftovers();
         if (leftovers.length > 0) {
-            logger.info(`[Bootstrap] ${leftovers.length} leftover envelopes from previous run — will flush`);
+            __DEV__ && logger.info(`[Bootstrap] ${leftovers.length} leftover envelopes from previous run — will flush`);
             // Re-add to queue so the normal flush cycle picks them up
             for (const envelope of leftovers) {
                 persistentQueue.add(envelope);
@@ -145,9 +145,9 @@ export class SDKBootstrapper {
         // ── Backend handshake ──────────────────────────────────
         if (this.config.clientKey) {
             // SaaS mode: clientKey is resolved by SdkKeyGuard on each request — no token handshake needed
-            logger.info('[Bootstrap] SaaS mode: clientKey auth active, skipping legacy handshake');
+            __DEV__ && logger.info('[Bootstrap] SaaS mode: clientKey auth active, skipping legacy handshake');
         } else {
-            logger.debug('Starting handshake...');
+            __DEV__ && logger.debug('Starting handshake...');
             const response = await httpClient.post(ENDPOINTS.SESSIONS, {
                 projectId: this.config.projectId,
                 publishableKey: this.config.publishableKey,
@@ -340,7 +340,7 @@ export class SDKBootstrapper {
         // ── Session Replay Initialization (Core) ───────────────
         if (features.replay !== false) {
             try {
-                logger.debug('[Bootstrap] Initializing unified SessionManager');
+                __DEV__ && logger.debug('[Bootstrap] Initializing unified SessionManager');
                 const sessionManager = SessionManager.getInstance(
                     null, // No desktop transport initially
                     nativeCapture,
@@ -395,15 +395,18 @@ export class SDKBootstrapper {
                         const analyticsStarted = backendAdapter
                             .startAnalyticsSession(this._buildAnalyticsSession());
 
-                        // Cold-launch frame recording. The AppState listener only
-                        // starts a recording session on a foreground TRANSITION, which
-                        // never fires on the initial launch — so without this the first
-                        // session uploads events but zero frames ("No screen recordings").
-                        // Start it once the analytics session id exists so startSession
-                        // adopts it (one-row merge) instead of minting an orphan row.
-                        // Gated by the same finalizeOnBackground flag as the per-foreground
-                        // recording path above.
-                        if (this.config.finalizeOnBackground) {
+                        // Cold-launch frame recording. The AppState listener only starts a
+                        // recording session on a foreground TRANSITION, which never fires on the
+                        // initial launch — so without this the first session uploads events but zero
+                        // frames ("No screen recordings"). Auto-start recording by DEFAULT in SaaS mode
+                        // so replays appear out of the box; hosts opt out with `replay: { record: false }`
+                        // for events-only sessions (they can still record on demand via startSession()).
+                        // Deliberately NOT gated by finalizeOnBackground (that flag only governs
+                        // per-foreground session boundaries, not whether replay records at all).
+                        // Started once the analytics session id exists so startSession adopts it
+                        // (one-row merge) instead of minting an orphan row.
+                        const shouldAutoRecord = this.config.replay?.record !== false;
+                        if (shouldAutoRecord) {
                             analyticsStarted
                                 .then(() => {
                                     if (!sessionManager.isActive) {
@@ -421,7 +424,7 @@ export class SDKBootstrapper {
                 // Desktop transport is attached lazily by sessionWiring.ts when
                 // enableDebug() is called (development only — production skips this).
                 const isSaaS = !!this.config.clientKey;
-                logger.info(
+                __DEV__ && logger.info(
                     `[ScaleBun Session Wiring] mode=${isSaaS ? 'saas' : 'legacy'} ` +
                     `backend=${!!this.config.apiBaseUrl} desktop=pending-debug-connect`
                 );
@@ -481,10 +484,10 @@ export class SDKBootstrapper {
                     }
                 } catch { /* no-throw */ }
 
-                logger.debug(`[AutoScreen] Screen → '${screenName}' (source: ${source})`);
+                __DEV__ && logger.debug(`[AutoScreen] Screen → '${screenName}' (source: ${source})`);
             });
             detector.start();
-            logger.info('[Bootstrap] Auto screen detection started');
+            __DEV__ && logger.info('[Bootstrap] Auto screen detection started');
 
             /**
              * Screen detection that never resolves anything must SAY so.
@@ -520,7 +523,7 @@ export class SDKBootstrapper {
             deviceId: getDeviceId(),
         });
 
-        logger.info('SDK initialized and session established');
+        __DEV__ && logger.info('SDK initialized and session established');
 
         return {
             config: this.config,

package/src/compat/codepush.ts

@@ -1,4 +1,5 @@
 import { otaOrchestrator } from '../features/ota/OtaOrchestrator';
+import { logger } from '../core/logger/internalLogger';
 
 export enum CodePushInstallMode {
   IMMEDIATE = 0,
@@ -38,12 +39,57 @@ export interface CodePushPackage {
 }
 
 /**
- * Microsoft CodePush Drop-in Compatibility Shim — Sprint 10 (S10-CLI-1).
+ * Microsoft CodePush compatibility shim.
  *
- * Allows developers to migrate from CodePush to Scalebun OTA by simply changing:
- *   - import codePush from 'react-native-code-push'
- *   + import codePush from '@scalebun/react-native/compat/codepush'
+ * Maps the CodePush surface (`sync`, `checkForUpdate`, the HOC) onto the
+ * ScaleBun orchestrator so a migrating app keeps compiling while its call sites
+ * are ported.
+ *
+ * CONFIGURE IT FIRST. This shim used to carry hardcoded defaults —
+ * `http://localhost:3001/api/v1` with a dev client key — so a migrated
+ * production app silently checked localhost forever and reported UP_TO_DATE on
+ * every sync. There is no correct default for someone else's backend, so there
+ * is now none: call `configureCodePushShim()` (or `ScaleBun.init({ ota })`,
+ * which the facade wires for you) before the first sync, and an unconfigured
+ * shim says so loudly instead of pretending to be up to date.
+ *
+ *   import codePush, { configureCodePushShim } from '@scalebun/react-native/compat/codepush';
+ *   configureCodePushShim({ apiUrl, clientKey, appVersion, installationId });
+ */
+
+export interface CodePushShimConfig {
+    /** Backend base URL, e.g. https://api.yourbackend.com/api/v1 */
+    apiUrl: string;
+    /** SDK client key for this app/environment. */
+    clientKey: string;
+    /** Native app version this binary reports (e.g. '1.4.0'). */
+    appVersion: string;
+    /** Stable per-install id. Defaults to the SDK's canonical installation id. */
+    installationId?: string;
+}
+
+let shimConfig: CodePushShimConfig | null = null;
+
+/** Point the shim at a real backend. Required before sync/checkForUpdate. */
+export function configureCodePushShim(config: CodePushShimConfig): void {
+    shimConfig = config;
+}
+
+/**
+ * Resolve the sync params, or null when unconfigured. Returning null (rather
+ * than substituting a localhost default) is what turns a silent no-update into
+ * a visible, fixable error.
  */
+function shimParams(): CodePushShimConfig | null {
+    if (!shimConfig) {
+        logger.warn(
+            '[ScaleBun] CodePush shim is not configured — no update check was performed. ' +
+                'Call configureCodePushShim({ apiUrl, clientKey, appVersion }) during startup.',
+        );
+        return null;
+    }
+    return shimConfig;
+}
 const codePushShim = function <P>(rootComponent: React.ComponentType<P>) {
   return rootComponent;
 };
@@ -53,14 +99,21 @@ codePushShim.sync = async (
   syncStatusCallback?: (status: CodePushSyncStatus) => void,
   downloadProgressCallback?: (progress: { receivedBytes: number; totalBytes: number }) => void,
 ): Promise<CodePushSyncStatus> => {
+  const params = shimParams();
+  if (!params) {
+    // Unconfigured is an ERROR, not "up to date": reporting UP_TO_DATE here is
+    // exactly how a broken migration stays invisible for months.
+    syncStatusCallback?.(CodePushSyncStatus.UNKNOWN_ERROR);
+    return CodePushSyncStatus.UNKNOWN_ERROR;
+  }
   try {
     syncStatusCallback?.(CodePushSyncStatus.CHECKING_FOR_UPDATE);
     const result = await otaOrchestrator.sync({
-      apiUrl: 'http://localhost:3001/api/v1',
-      clientKey: 'scalebun_ck_dev_default_0000000000000000000000',
-      appVersion: '1.0.0',
-      installationId: 'codepush_shim',
-    });
+      ...params,
+      // Omitted → the orchestrator falls back to the SDK's canonical
+      // installation id, which is the right identity anyway.
+      ...(params.installationId ? { installationId: params.installationId } : {}),
+    } as any);
 
     if (result.status === 'UP_TO_DATE') {
       syncStatusCallback?.(CodePushSyncStatus.UP_TO_DATE);
@@ -81,16 +134,16 @@ codePushShim.sync = async (
 };
 
 codePushShim.checkForUpdate = async (): Promise<CodePushPackage | null> => {
+  const params = shimParams();
+  if (!params) return null;
   const check = await otaOrchestrator.checkForUpdate({
-    apiUrl: 'http://localhost:3001/api/v1',
-    clientKey: 'scalebun_ck_dev_default_0000000000000000000000',
-    appVersion: '1.0.0',
-    installationId: 'codepush_shim',
-  });
+    ...params,
+    ...(params.installationId ? { installationId: params.installationId } : {}),
+  } as any);
   if (check.action === 'NONE' || !check.bundle) return null;
 
   return {
-    appVersion: '1.0.0',
+    appVersion: params.appVersion,
     deploymentKey: 'scalebun_ota',
     description: check.bundle.releaseNote ?? '',
     failedInstall: false,
@@ -111,8 +164,26 @@ codePushShim.allowRestart = () => {
   // Scalebun handles restart safety automatically via boot guard
 };
 
+/**
+ * Metadata for the bundle currently RUNNING. CodePush apps use this to show a
+ * version or decide whether a pending update landed; returning a flat null
+ * (as this did) makes every such check read as "no OTA bundle installed".
+ */
 codePushShim.getUpdateMetadata = async (): Promise<CodePushPackage | null> => {
-  return null;
+  const current = otaOrchestrator.getCurrentBundle();
+  if (!current) return null;
+  return {
+    appVersion: shimConfig?.appVersion ?? '',
+    deploymentKey: 'scalebun_ota',
+    description: current.releaseNote ?? '',
+    failedInstall: false,
+    isFirstRun: false,
+    isMandatory: current.isMandatory ?? false,
+    isPending: false,
+    label: `v${current.version}`,
+    packageHash: current.sha256,
+    packageSize: current.size,
+  };
 };
 
 export default codePushShim;