yaver-feedback-react-native 0.5.2 → 0.5.4

package/README.md

@@ -4,6 +4,14 @@ Visual feedback SDK for Yaver. Lets testers and developers shake their phone (or
 
 ## Installation
 
+```bash
+npm install -g yaver-cli
+cd your-app
+yaver feedback setup
+```
+
+Manual fallback:
+
 ```bash
 npm install yaver-feedback-react-native
 ```

package/dist/AuthOverlay.d.ts

@@ -0,0 +1,16 @@
+import React from 'react';
+/**
+ * Presentation layer for the SDK's auth + machine-picker modals.
+ *
+ * Mounts automatically inside `<FeedbackModal />`, so consumers of the SDK
+ * get in-app login with no extra wiring. It listens for events emitted by
+ * `YaverFeedback.showLogin()` / `showMachinePicker()`:
+ *
+ *   yaverFeedback:startLogin          → show login modal
+ *   yaverFeedback:startMachinePicker  → show machine picker
+ *
+ * The overlay closes itself once login/pick succeeds, then re-emits
+ * `yaverFeedback:startReport` so the user continues straight into the
+ * feedback flow they originally triggered.
+ */
+export declare const AuthOverlay: React.FC;

package/dist/AuthOverlay.js

@@ -0,0 +1,104 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthOverlay = void 0;
+const react_1 = __importStar(require("react"));
+const react_native_1 = require("react-native");
+const LoginScreen_1 = require("./LoginScreen");
+const MachinePickerScreen_1 = require("./MachinePickerScreen");
+const YaverFeedback_1 = require("./YaverFeedback");
+const auth_1 = require("./auth");
+/**
+ * Presentation layer for the SDK's auth + machine-picker modals.
+ *
+ * Mounts automatically inside `<FeedbackModal />`, so consumers of the SDK
+ * get in-app login with no extra wiring. It listens for events emitted by
+ * `YaverFeedback.showLogin()` / `showMachinePicker()`:
+ *
+ *   yaverFeedback:startLogin          → show login modal
+ *   yaverFeedback:startMachinePicker  → show machine picker
+ *
+ * The overlay closes itself once login/pick succeeds, then re-emits
+ * `yaverFeedback:startReport` so the user continues straight into the
+ * feedback flow they originally triggered.
+ */
+const AuthOverlay = () => {
+    const [loginVisible, setLoginVisible] = (0, react_1.useState)(false);
+    const [pickerVisible, setPickerVisible] = (0, react_1.useState)(false);
+    const [token, setToken] = (0, react_1.useState)(null);
+    (0, react_1.useEffect)(() => {
+        let mounted = true;
+        (async () => {
+            const cached = await (0, auth_1.getToken)();
+            if (mounted && cached)
+                setToken(cached);
+        })();
+        const loginSub = react_native_1.DeviceEventEmitter.addListener('yaverFeedback:startLogin', () => setLoginVisible(true));
+        const pickerSub = react_native_1.DeviceEventEmitter.addListener('yaverFeedback:startMachinePicker', async () => {
+            const cached = await (0, auth_1.getToken)();
+            if (cached)
+                setToken(cached);
+            if (cached)
+                setPickerVisible(true);
+        });
+        return () => {
+            mounted = false;
+            loginSub.remove();
+            pickerSub.remove();
+        };
+    }, []);
+    const handleLoggedIn = async (newToken) => {
+        setToken(newToken);
+        await YaverFeedback_1.YaverFeedback.setAuthToken(newToken);
+        setLoginVisible(false);
+        setPickerVisible(true);
+    };
+    const handleDevicePicked = async (device) => {
+        await YaverFeedback_1.YaverFeedback.setPreferredDevice(device.deviceId);
+        setPickerVisible(false);
+        // Continue straight into the feedback flow the user originally triggered.
+        react_native_1.DeviceEventEmitter.emit('yaverFeedback:startReport');
+    };
+    return (<>
+      <react_native_1.Modal visible={loginVisible} animationType="slide" presentationStyle="fullScreen" onRequestClose={() => setLoginVisible(false)}>
+        <LoginScreen_1.YaverLoginScreen onLoggedIn={handleLoggedIn} onCancel={() => setLoginVisible(false)}/>
+      </react_native_1.Modal>
+
+      <react_native_1.Modal visible={pickerVisible && !!token} animationType="slide" presentationStyle="fullScreen" onRequestClose={() => setPickerVisible(false)}>
+        {token && (<MachinePickerScreen_1.YaverMachinePickerScreen token={token} onPick={handleDevicePicked} onCancel={() => setPickerVisible(false)}/>)}
+      </react_native_1.Modal>
+    </>);
+};
+exports.AuthOverlay = AuthOverlay;

package/dist/BlackBox.d.ts

@@ -0,0 +1,154 @@
+/**
+ * Black box event types streamed from the device to the agent.
+ * These mirror the Go BlackBoxEvent struct on the agent side.
+ */
+export interface BlackBoxEvent {
+    type: 'log' | 'error' | 'navigation' | 'lifecycle' | 'network' | 'state' | 'render' | 'track';
+    level?: 'info' | 'warn' | 'error';
+    message: string;
+    timestamp: number;
+    stack?: string[];
+    isFatal?: boolean;
+    metadata?: Record<string, unknown>;
+    source?: string;
+    duration?: number;
+    route?: string;
+    prevRoute?: string;
+}
+/** Configuration for the black box stream. */
+export interface BlackBoxConfig {
+    /** Device identifier (defaults to a generated UUID). */
+    deviceId?: string;
+    /** Application name for the agent to display. */
+    appName?: string;
+    /** Flush interval in ms — how often buffered events are sent. Default: 2000. */
+    flushInterval?: number;
+    /** Max events to buffer before flushing. Default: 50. */
+    maxBufferSize?: number;
+}
+/**
+ * Flight-recorder-style streaming from the device to the Yaver agent.
+ *
+ * Captures logs, errors, navigation, lifecycle events, network requests,
+ * and state changes — then streams them continuously to the agent's
+ * `/blackbox/events` endpoint.
+ *
+ * The agent uses this context when the developer asks for a fix — it
+ * already knows what the app was doing.
+ *
+ * **Does not hijack any global handlers.** All capture is explicit:
+ * - Call `BlackBox.log()` / `.warn()` / `.error()` for console-style logs
+ * - Call `BlackBox.navigation()` for screen changes
+ * - Call `BlackBox.networkRequest()` for HTTP activity
+ * - Use `BlackBox.wrapConsole()` to intercept console.log/warn/error
+ *   (only if you explicitly opt in — no auto-hooking)
+ */
+/** Command received from the agent via the SSE command channel. */
+export interface BlackBoxCommand {
+    command: string;
+    data?: Record<string, unknown>;
+}
+/** Callback type for handling agent commands. */
+export type CommandHandler = (cmd: BlackBoxCommand) => void;
+export declare class BlackBox {
+    private static baseUrl;
+    private static authToken;
+    private static deviceId;
+    private static appName;
+    private static buffer;
+    private static flushTimer;
+    private static flushInterval;
+    private static maxBufferSize;
+    private static started;
+    private static originalConsole;
+    private static sseAbortController;
+    private static sseReconnectTimer;
+    private static commandHandlers;
+    private static sseConnected;
+    /**
+     * Start the black box stream. Call after `YaverFeedback.init()`.
+     *
+     * The stream sends buffered events to the agent every `flushInterval` ms,
+     * or immediately when the buffer reaches `maxBufferSize`.
+     */
+    static start(config?: BlackBoxConfig): void;
+    /** Stop the black box stream and flush remaining events. */
+    static stop(): void;
+    /** Whether the black box is currently streaming. */
+    static get isStreaming(): boolean;
+    static log(message: string, source?: string, metadata?: Record<string, unknown>): void;
+    static warn(message: string, source?: string, metadata?: Record<string, unknown>): void;
+    static error(message: string, source?: string, metadata?: Record<string, unknown>): void;
+    /**
+     * Record a business event. Fires into the analytics ledger on
+     * the agent — see GET /analytics/events.csv.
+     *
+     * @example
+     * ```ts
+     * BlackBox.track('purchase_completed', {
+     *   amount: '9.99',
+     *   currency: 'USD',
+     *   plan: 'pro',
+     * });
+     * ```
+     */
+    static track(name: string, props?: Record<string, unknown>, route?: string): void;
+    /** Record a caught error with stack trace. Also adds to the feedback error buffer. */
+    static captureError(err: Error, isFatal?: boolean, metadata?: Record<string, unknown>): void;
+    /** Record a screen/route navigation event. */
+    static navigation(route: string, prevRoute?: string, metadata?: Record<string, unknown>): void;
+    /** Record an app lifecycle event (mount, unmount, background, foreground). */
+    static lifecycle(event: string, metadata?: Record<string, unknown>): void;
+    /** Record a network request/response. */
+    static networkRequest(method: string, url: string, status?: number, durationMs?: number, metadata?: Record<string, unknown>): void;
+    /** Record a state change event (Redux action, context update, etc.). */
+    static stateChange(description: string, metadata?: Record<string, unknown>): void;
+    /** Record a render/re-render event with optional duration. */
+    static render(component: string, durationMs?: number, metadata?: Record<string, unknown>): void;
+    /**
+     * Wrap `console.log`, `console.warn`, and `console.error` to also
+     * stream them to the black box. **Call this explicitly** — the SDK
+     * never auto-hooks console.
+     *
+     * Call `BlackBox.unwrapConsole()` to restore originals.
+     */
+    static wrapConsole(): void;
+    /** Restore original console methods. */
+    static unwrapConsole(): void;
+    /**
+     * Returns a pass-through error handler that streams errors to the
+     * black box AND calls the next handler. Same pattern as
+     * `YaverFeedback.wrapErrorHandler`, but streams in real-time.
+     *
+     * @example
+     * const existing = ErrorUtils.getGlobalHandler();
+     * ErrorUtils.setGlobalHandler(BlackBox.wrapErrorHandler(existing));
+     */
+    static wrapErrorHandler(next?: ((error: Error, isFatal?: boolean) => void) | null): (error: Error, isFatal?: boolean) => void;
+    /**
+     * Register a handler for commands pushed by the agent.
+     * The primary use case is receiving "reload" commands when the vibe coder
+     * triggers a reload from the Yaver mobile app.
+     *
+     * @example
+     * BlackBox.onCommand((cmd) => {
+     *   if (cmd.command === 'reload') {
+     *     DevSettings.reload(); // or Updates.reloadAsync()
+     *   }
+     * });
+     */
+    static onCommand(handler: CommandHandler): () => void;
+    /** Whether the SSE command channel is connected. */
+    static get isCommandChannelConnected(): boolean;
+    /**
+     * Connect to the agent's /blackbox/stream SSE endpoint.
+     * This persistent connection allows the agent to push commands (reload, etc.)
+     * back to the SDK. Events are still sent via batch POST /blackbox/events.
+     */
+    private static connectSSE;
+    private static disconnectSSE;
+    private static scheduleSSEReconnect;
+    private static push;
+    private static flush;
+    private static generateDeviceId;
+}

package/dist/BlackBox.js

@@ -0,0 +1,395 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BlackBox = void 0;
+const react_native_1 = require("react-native");
+const YaverFeedback_1 = require("./YaverFeedback");
+class BlackBox {
+    /**
+     * Start the black box stream. Call after `YaverFeedback.init()`.
+     *
+     * The stream sends buffered events to the agent every `flushInterval` ms,
+     * or immediately when the buffer reaches `maxBufferSize`.
+     */
+    static start(config) {
+        const feedbackConfig = YaverFeedback_1.YaverFeedback.getConfig();
+        if (!feedbackConfig?.agentUrl) {
+            console.warn('[BlackBox] No agent URL. Call YaverFeedback.init() first or set agentUrl.');
+            return;
+        }
+        BlackBox.baseUrl = feedbackConfig.agentUrl.replace(/\/$/, '');
+        BlackBox.authToken = feedbackConfig.authToken ?? null;
+        BlackBox.deviceId = config?.deviceId ?? BlackBox.generateDeviceId();
+        BlackBox.appName = config?.appName ?? '';
+        BlackBox.flushInterval = config?.flushInterval ?? 2000;
+        BlackBox.maxBufferSize = config?.maxBufferSize ?? 50;
+        BlackBox.buffer = [];
+        BlackBox.started = true;
+        // Start periodic flush
+        if (BlackBox.flushTimer)
+            clearInterval(BlackBox.flushTimer);
+        BlackBox.flushTimer = setInterval(() => BlackBox.flush(), BlackBox.flushInterval);
+        // Log the session start
+        BlackBox.push({
+            type: 'lifecycle',
+            message: 'Black box streaming started',
+            timestamp: Date.now(),
+        });
+        // Connect SSE command channel for receiving agent commands (reload, etc.)
+        BlackBox.connectSSE();
+    }
+    /** Stop the black box stream and flush remaining events. */
+    static stop() {
+        if (!BlackBox.started)
+            return;
+        BlackBox.push({
+            type: 'lifecycle',
+            message: 'Black box streaming stopped',
+            timestamp: Date.now(),
+        });
+        BlackBox.flush();
+        if (BlackBox.flushTimer) {
+            clearInterval(BlackBox.flushTimer);
+            BlackBox.flushTimer = null;
+        }
+        BlackBox.disconnectSSE();
+        BlackBox.started = false;
+    }
+    /** Whether the black box is currently streaming. */
+    static get isStreaming() {
+        return BlackBox.started;
+    }
+    // ─── Logging ─────────────────────────────────────────────────────
+    static log(message, source, metadata) {
+        BlackBox.push({ type: 'log', level: 'info', message, timestamp: Date.now(), source, metadata });
+    }
+    static warn(message, source, metadata) {
+        BlackBox.push({ type: 'log', level: 'warn', message, timestamp: Date.now(), source, metadata });
+    }
+    static error(message, source, metadata) {
+        BlackBox.push({ type: 'log', level: 'error', message, timestamp: Date.now(), source, metadata });
+    }
+    // ─── Track events ────────────────────────────────────────────────
+    //
+    // Business-event ingest. Routed into the agent's analytics ledger
+    // via the same BlackBox stream so the dev doesn't pay Mixpanel
+    // / Amplitude for "the user tapped Purchase." Zero dashboards in
+    // yaver; export to CSV / webhook into PostHog if you want charts.
+    /**
+     * Record a business event. Fires into the analytics ledger on
+     * the agent — see GET /analytics/events.csv.
+     *
+     * @example
+     * ```ts
+     * BlackBox.track('purchase_completed', {
+     *   amount: '9.99',
+     *   currency: 'USD',
+     *   plan: 'pro',
+     * });
+     * ```
+     */
+    static track(name, props, route) {
+        if (!name)
+            return;
+        BlackBox.push({
+            type: 'track',
+            message: name,
+            timestamp: Date.now(),
+            route,
+            metadata: props,
+        });
+    }
+    // ─── Errors ──────────────────────────────────────────────────────
+    /** Record a caught error with stack trace. Also adds to the feedback error buffer. */
+    static captureError(err, isFatal = false, metadata) {
+        const stack = (err.stack ?? '').split('\n').filter((l) => l.trim());
+        BlackBox.push({
+            type: 'error',
+            message: err.message,
+            timestamp: Date.now(),
+            stack,
+            isFatal,
+            metadata,
+        });
+        // Also feed into the feedback SDK error buffer
+        YaverFeedback_1.YaverFeedback.attachError(err, metadata);
+    }
+    // ─── Navigation ──────────────────────────────────────────────────
+    /** Record a screen/route navigation event. */
+    static navigation(route, prevRoute, metadata) {
+        BlackBox.push({
+            type: 'navigation',
+            message: `Navigate: ${prevRoute ? prevRoute + ' -> ' : ''}${route}`,
+            timestamp: Date.now(),
+            route,
+            prevRoute,
+            metadata,
+        });
+    }
+    // ─── Lifecycle ───────────────────────────────────────────────────
+    /** Record an app lifecycle event (mount, unmount, background, foreground). */
+    static lifecycle(event, metadata) {
+        BlackBox.push({ type: 'lifecycle', message: event, timestamp: Date.now(), metadata });
+    }
+    // ─── Network ─────────────────────────────────────────────────────
+    /** Record a network request/response. */
+    static networkRequest(method, url, status, durationMs, metadata) {
+        const msg = status != null
+            ? `${method} ${url} → ${status}`
+            : `${method} ${url}`;
+        BlackBox.push({
+            type: 'network',
+            message: msg,
+            timestamp: Date.now(),
+            duration: durationMs,
+            metadata,
+        });
+    }
+    // ─── State ───────────────────────────────────────────────────────
+    /** Record a state change event (Redux action, context update, etc.). */
+    static stateChange(description, metadata) {
+        BlackBox.push({ type: 'state', message: description, timestamp: Date.now(), metadata });
+    }
+    // ─── Render ──────────────────────────────────────────────────────
+    /** Record a render/re-render event with optional duration. */
+    static render(component, durationMs, metadata) {
+        BlackBox.push({
+            type: 'render',
+            message: component,
+            timestamp: Date.now(),
+            duration: durationMs,
+            metadata,
+        });
+    }
+    // ─── Console wrapping (opt-in) ───────────────────────────────────
+    /**
+     * Wrap `console.log`, `console.warn`, and `console.error` to also
+     * stream them to the black box. **Call this explicitly** — the SDK
+     * never auto-hooks console.
+     *
+     * Call `BlackBox.unwrapConsole()` to restore originals.
+     */
+    static wrapConsole() {
+        if (BlackBox.originalConsole)
+            return; // Already wrapped
+        BlackBox.originalConsole = {
+            log: console.log,
+            warn: console.warn,
+            error: console.error,
+        };
+        console.log = (...args) => {
+            BlackBox.originalConsole.log(...args);
+            BlackBox.log(args.map(String).join(' '));
+        };
+        console.warn = (...args) => {
+            BlackBox.originalConsole.warn(...args);
+            BlackBox.warn(args.map(String).join(' '));
+        };
+        console.error = (...args) => {
+            BlackBox.originalConsole.error(...args);
+            BlackBox.error(args.map(String).join(' '));
+        };
+    }
+    /** Restore original console methods. */
+    static unwrapConsole() {
+        if (!BlackBox.originalConsole)
+            return;
+        console.log = BlackBox.originalConsole.log;
+        console.warn = BlackBox.originalConsole.warn;
+        console.error = BlackBox.originalConsole.error;
+        BlackBox.originalConsole = null;
+    }
+    // ─── Error handler wrapper (opt-in) ──────────────────────────────
+    /**
+     * Returns a pass-through error handler that streams errors to the
+     * black box AND calls the next handler. Same pattern as
+     * `YaverFeedback.wrapErrorHandler`, but streams in real-time.
+     *
+     * @example
+     * const existing = ErrorUtils.getGlobalHandler();
+     * ErrorUtils.setGlobalHandler(BlackBox.wrapErrorHandler(existing));
+     */
+    static wrapErrorHandler(next) {
+        return (error, isFatal) => {
+            BlackBox.captureError(error, isFatal ?? false);
+            next?.(error, isFatal);
+        };
+    }
+    // ─── Command channel (agent → SDK) ──────────────────────────────
+    /**
+     * Register a handler for commands pushed by the agent.
+     * The primary use case is receiving "reload" commands when the vibe coder
+     * triggers a reload from the Yaver mobile app.
+     *
+     * @example
+     * BlackBox.onCommand((cmd) => {
+     *   if (cmd.command === 'reload') {
+     *     DevSettings.reload(); // or Updates.reloadAsync()
+     *   }
+     * });
+     */
+    static onCommand(handler) {
+        BlackBox.commandHandlers.push(handler);
+        // Return unsubscribe function
+        return () => {
+            BlackBox.commandHandlers = BlackBox.commandHandlers.filter(h => h !== handler);
+        };
+    }
+    /** Whether the SSE command channel is connected. */
+    static get isCommandChannelConnected() {
+        return BlackBox.sseConnected;
+    }
+    /**
+     * Connect to the agent's /blackbox/stream SSE endpoint.
+     * This persistent connection allows the agent to push commands (reload, etc.)
+     * back to the SDK. Events are still sent via batch POST /blackbox/events.
+     */
+    static async connectSSE() {
+        if (!BlackBox.baseUrl || !BlackBox.authToken)
+            return;
+        // Disconnect any existing connection
+        BlackBox.disconnectSSE();
+        const controller = new AbortController();
+        BlackBox.sseAbortController = controller;
+        const url = `${BlackBox.baseUrl}/blackbox/command-stream?device=${encodeURIComponent(BlackBox.deviceId)}`;
+        try {
+            const response = await fetch(url, {
+                method: 'GET',
+                headers: {
+                    Authorization: `Bearer ${BlackBox.authToken}`,
+                    'X-Device-ID': BlackBox.deviceId,
+                    'X-Platform': react_native_1.Platform.OS,
+                    'X-App-Name': BlackBox.appName,
+                    Accept: 'text/event-stream',
+                },
+                // @ts-ignore — React Native supports signal on fetch
+                signal: controller.signal,
+            });
+            if (!response.ok || !response.body) {
+                BlackBox.scheduleSSEReconnect();
+                return;
+            }
+            BlackBox.sseConnected = true;
+            // Read SSE stream
+            const reader = response.body.getReader();
+            const decoder = new TextDecoder();
+            let buffer = '';
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                buffer += decoder.decode(value, { stream: true });
+                const lines = buffer.split('\n');
+                buffer = lines.pop() ?? '';
+                for (const line of lines) {
+                    if (!line.startsWith('data: '))
+                        continue;
+                    try {
+                        const msg = JSON.parse(line.slice(6));
+                        if (msg.type === 'command' && msg.command) {
+                            const cmd = msg.command;
+                            for (const handler of BlackBox.commandHandlers) {
+                                try {
+                                    handler(cmd);
+                                }
+                                catch {
+                                    // Handler error — don't break the loop
+                                }
+                            }
+                        }
+                    }
+                    catch {
+                        // Malformed SSE data — skip
+                    }
+                }
+            }
+        }
+        catch (err) {
+            // AbortError is expected on disconnect
+            if (err instanceof Error && err.name === 'AbortError')
+                return;
+        }
+        finally {
+            BlackBox.sseConnected = false;
+        }
+        // Reconnect if still running
+        if (BlackBox.started) {
+            BlackBox.scheduleSSEReconnect();
+        }
+    }
+    static disconnectSSE() {
+        if (BlackBox.sseAbortController) {
+            BlackBox.sseAbortController.abort();
+            BlackBox.sseAbortController = null;
+        }
+        if (BlackBox.sseReconnectTimer) {
+            clearTimeout(BlackBox.sseReconnectTimer);
+            BlackBox.sseReconnectTimer = null;
+        }
+        BlackBox.sseConnected = false;
+    }
+    static scheduleSSEReconnect() {
+        if (!BlackBox.started)
+            return;
+        if (BlackBox.sseReconnectTimer)
+            return;
+        // Reconnect after 5s
+        BlackBox.sseReconnectTimer = setTimeout(() => {
+            BlackBox.sseReconnectTimer = null;
+            if (BlackBox.started)
+                BlackBox.connectSSE();
+        }, 5000);
+    }
+    // ─── Internal ────────────────────────────────────────────────────
+    static push(event) {
+        if (!BlackBox.started)
+            return;
+        BlackBox.buffer.push(event);
+        if (BlackBox.buffer.length >= BlackBox.maxBufferSize) {
+            BlackBox.flush();
+        }
+    }
+    static async flush() {
+        if (!BlackBox.baseUrl || !BlackBox.authToken || BlackBox.buffer.length === 0)
+            return;
+        const events = BlackBox.buffer;
+        BlackBox.buffer = [];
+        try {
+            await fetch(`${BlackBox.baseUrl}/blackbox/events`, {
+                method: 'POST',
+                headers: {
+                    Authorization: `Bearer ${BlackBox.authToken}`,
+                    'Content-Type': 'application/json',
+                    'X-Device-ID': BlackBox.deviceId,
+                    'X-Platform': react_native_1.Platform.OS,
+                    'X-App-Name': BlackBox.appName,
+                },
+                body: JSON.stringify(events),
+            });
+        }
+        catch {
+            // Re-add failed events to buffer (capped to avoid memory growth)
+            if (BlackBox.buffer.length + events.length <= BlackBox.maxBufferSize * 2) {
+                BlackBox.buffer = [...events, ...BlackBox.buffer];
+            }
+        }
+    }
+    static generateDeviceId() {
+        return 'xxxxxxxx'.replace(/x/g, () => Math.floor(Math.random() * 16).toString(16));
+    }
+}
+exports.BlackBox = BlackBox;
+BlackBox.baseUrl = null;
+BlackBox.authToken = null;
+BlackBox.deviceId = '';
+BlackBox.appName = '';
+BlackBox.buffer = [];
+BlackBox.flushTimer = null;
+BlackBox.flushInterval = 2000;
+BlackBox.maxBufferSize = 50;
+BlackBox.started = false;
+BlackBox.originalConsole = null;
+// SSE command channel — persistent connection to /blackbox/stream
+BlackBox.sseAbortController = null;
+BlackBox.sseReconnectTimer = null;
+BlackBox.commandHandlers = [];
+BlackBox.sseConnected = false;