yaver-feedback-react-native 0.8.7 → 0.8.9

package/README.md

@@ -2,6 +2,8 @@
 
 Visual feedback SDK for Yaver. Lets testers and developers shake their phone and then keep a small quick-access icon on screen for hot reload, vibing, and screenshot & fix flows straight to a Yaver agent running on a dev machine.
 
+Haptics ownership rule: when your app is paired with Yaver, app-level haptics should belong to Yaver Feedback alone. If the host app also fires its own `expo-haptics` calls, you risk duplicated tactile feedback and a larger native-module crash surface during guest/runtime flows.
+
 ## Installation
 
 ```bash
@@ -618,6 +620,7 @@ YaverFeedback.init({
   // Optional
   agentUrl: 'http://192.168.1.10:18080',  // Agent URL (auto-discovered if omitted)
   trigger: 'shake',                        // 'shake' | 'floating-button' | 'manual'
+  disableShakeGesture: false,              // Non-default: disable shake + promote quick icon to 'always'
   enabled: true,                           // Default: __DEV__ (auto-disabled in production)
   maxRecordingDuration: 120,               // Max recording duration in seconds (default: 120)
   feedbackMode: 'batch',                   // 'live' | 'narrated' | 'batch' (default: 'batch')
@@ -662,6 +665,26 @@ SDK yields shake handling to Yaver's native overlay — see the
 YaverFeedback.init({ authToken, trigger: 'shake' });
 ```
 
+### No-shake build option
+
+If another surface owns motion / haptics and you want the SDK without shake detection, enable the non-default `disableShakeGesture` option:
+
+```typescript
+YaverFeedback.init({
+  authToken,
+  trigger: 'shake',
+  disableShakeGesture: true,
+});
+```
+
+Effects:
+
+- `ShakeDetector` is not started.
+- If `quickIcon` was unset / `'auto'`, the SDK promotes it to `'always'`.
+- The user opens feedback through the draggable quick icon or your own manual trigger.
+
+This is useful when Yaver Feedback should remain the only haptic/shake owner and the host app should not bind its own motion-triggered entry point.
+
 ### Floating Button
 
 A small draggable "Y" button overlays the app. Tap to open the feedback modal.

package/dist/MachinePickerScreen.js

@@ -121,8 +121,8 @@ const YaverMachinePickerScreen = ({ token, currentDeviceId, onPick, onCancel, })
         // yellows from phone↔backend clock skew around the 89-90 s mark.
         //
         // `runnerDown` intentionally does NOT flip the dot. That flag
-        // tracks whether the AI runner (claude-code, aider, ...) is
-        // healthy — a separate concern from "can I reach this machine?"
+        // tracks whether the AI runner (claude-code / codex / opencode)
+        // is healthy — a separate concern from "can I reach this machine?"
         // Mobile app surfaces runner issues via a separate badge, not
         // this dot. Picker's job is reachability, nothing more.
         const effectivelyReachable = probe?.reachable === true;

package/dist/YaverFeedback.js

@@ -13,10 +13,13 @@ const preferences_1 = require("./preferences");
 // (mobile/ios/Yaver/YaverInfo.{swift,m} + Android counterpart); a
 // standalone app bundled by its own developer has no such module.
 // When the SDK is loaded through Yaver's Hermes-push guest runtime we
-// deliberately no-op every public entry point — Yaver owns the shake
-// gesture ("Reload / Back to Yaver" overlay), the feedback capture
-// flow, and the BlackBox streaming; running a second copy from inside
-// the guest just produces duplicate UIs and double P2P sessions.
+// run in HOST MODE: dormant by default (no shake detector, no auto
+// BlackBox, no QuickActionIcon — Yaver's host shell owns those), but
+// we DO register a DeviceEventEmitter listener so Yaver's overlay can
+// flip the SDK live at runtime. When the user shakes inside the guest
+// app and taps "Feedback" on the Yaver overlay, AppDelegate dispatches
+// `yaverFeedback:startReport` into this bridge; the listener wakes the
+// SDK and opens the modal in-place over the running guest UI.
 function isRunningInsideYaverHost() {
     try {
         return !!react_native_1.NativeModules?.YaverInfo;
@@ -25,11 +28,108 @@ function isRunningInsideYaverHost() {
         return false;
     }
 }
-// Suppresses SDK activation when inside Yaver super-host. Callers of
-// YaverFeedback.init / startReport / startBatchRecording / … early-out
-// by checking this first so the SDK's side effects (accelerometer,
-// BlackBox HTTP, SSE command channel, FeedbackModal mount) never start.
-const YAVER_HOST_SUPPRESS = isRunningInsideYaverHost();
+// Two distinct compile-time modes for a guest app like sfmg / talos:
+//
+//   YAVER_HOST_MODE  — bundled by Yaver's agent (/dev/build-native) for
+//                      loading inside Yaver mobile. SDK code is in the
+//                      bundle but boots PASSIVE: no shake detector, no
+//                      auto-BlackBox, no container UI. Yaver's host
+//                      overlay owns the shake gesture; when the user
+//                      taps "Feedback" on Yaver's overlay, AppDelegate
+//                      dispatches yaverFeedback:hostActivate into this
+//                      bridge and the SDK runtime-flips active for a
+//                      single feedback session.
+//
+//   YAVER_SDK_MODE   — sfmg's own standalone TestFlight / Play Store
+//                      build, with the Yaver SDK embedded. SDK boots
+//                      active: shake → modal directly, no Yaver host
+//                      involved. Default for normal `expo build`.
+//
+// Both can be forced at build time via process.env. When neither is
+// set, fall back to runtime detection: if the YaverInfo native module
+// exists (we're inside Yaver), assume HOST_MODE; else SDK_MODE. This
+// keeps older bundles (built before the agent learned to set the env)
+// working unchanged.
+const YAVER_HOST_MODE_BUILD = (() => {
+    try {
+        const v = process.env?.YAVER_HOST_MODE;
+        return v === 'true' || v === '1' || v === true || v === 1;
+    }
+    catch {
+        return false;
+    }
+})();
+const YAVER_SDK_MODE_BUILD = (() => {
+    try {
+        const v = process.env?.YAVER_SDK_MODE;
+        return v === 'true' || v === '1' || v === true || v === 1;
+    }
+    catch {
+        return false;
+    }
+})();
+// Effective mode after considering build flags AND runtime detection.
+const IS_HOST_MODE = YAVER_HOST_MODE_BUILD ||
+    (!YAVER_SDK_MODE_BUILD && isRunningInsideYaverHost());
+// Tracks whether we've been runtime-activated by the host (sfmg-in-Yaver
+// case). Independent of `enabled` so we can tell "host turned us on for
+// one shot" apart from "developer toggled enabled programmatically".
+let hostActivated = false;
+// Host-activation listener. Always registered when in HOST mode so a
+// Yaver overlay tap can wake the SDK even before the guest's
+// YaverFeedback.init() runs. AppDelegate (mobile/ios/Yaver/AppDelegate.
+// swift::handleFeedbackTap) sends `yaverFeedback:startReport` into the
+// guest bridge when the user picks Feedback on the shake overlay.
+//
+// Activation flow:
+//   1. Try Yaver's existing bearer (NativeModules.YaverInfo.
+//      inheritedAuthToken, populated by Yaver mobile's auth.ts on
+//      sign-in). Validate against /auth/validate before trusting.
+//   2. If valid: setAuthToken + open feedback modal in-place (the
+//      modal already supports hot reload, screenshot, vibing chat).
+//   3. If missing or invalid: open the SDK's own login screen.
+if (IS_HOST_MODE) {
+    try {
+        const { DeviceEventEmitter } = require('react-native');
+        DeviceEventEmitter.addListener('yaverFeedback:startReport', () => {
+            hostActivated = true;
+            enabled = true;
+            void (async () => {
+                const yi = react_native_1.NativeModules?.YaverInfo;
+                const inheritedToken = String(yi?.inheritedAuthToken || '').trim();
+                const inheritedAgent = String(yi?.inheritedAgentUrl || '').trim();
+                const inheritedDevice = String(yi?.inheritedDeviceId || '').trim();
+                if (inheritedToken) {
+                    // Lazy-import auth.ts so module load doesn't drag the auth
+                    // network code into the active set when the SDK is dormant.
+                    const { validateToken } = require('./auth');
+                    const user = await validateToken(inheritedToken).catch(() => null);
+                    if (user) {
+                        // Seed config + connect the SDK to the host's auth.
+                        if (!config) {
+                            YaverFeedback.init({
+                                authToken: inheritedToken,
+                                agentUrl: inheritedAgent || undefined,
+                                preferredDeviceId: inheritedDevice || undefined,
+                            });
+                        }
+                        await YaverFeedback.setAuthToken(inheritedToken);
+                        await YaverFeedback.startReport();
+                        return;
+                    }
+                }
+                // No token, or token invalid — fall through to the SDK's own
+                // login screen. The user picks an OAuth provider; on success
+                // the modal continues with the new token.
+                if (!config) {
+                    YaverFeedback.init({});
+                }
+                YaverFeedback.showLogin();
+            })();
+        });
+    }
+    catch { /* react-native unavailable in jsdom unit tests */ }
+}
 let config = null;
 let enabled = false;
 let p2pClient = null;
@@ -102,17 +202,37 @@ class YaverFeedback {
      * via `YaverDiscovery` on the first `startReport()` call.
      */
     static init(cfg) {
-        if (YAVER_HOST_SUPPRESS) {
-            // Running inside Yaver's super-host — yield to Yaver's native UX.
-            enabled = false;
-            return;
-        }
         config = {
             trigger: 'shake',
             maxRecordingDuration: 120,
             autoLogin: true,
             ...cfg,
         };
+        if (IS_HOST_MODE) {
+            // sfmg / talos / etc. running inside Yaver mobile (compile-time
+            // YAVER_HOST_MODE or runtime-detected). Store config so a later
+            // host activation (yaverFeedback:startReport from AppDelegate)
+            // can open the modal — but skip the side effects Yaver's host
+            // shell owns: shake detector, auto-BlackBox, QuickActionIcon.
+            enabled = false;
+            // Configure auth endpoints + strict-native-auth even in passive
+            // mode so a host-activated session uses the same login routing
+            // the standalone path would.
+            (0, auth_1.configureAuthEndpoints)({
+                convexSiteUrl: cfg.authConvexSiteUrl,
+                webBaseUrl: cfg.authWebBaseUrl,
+            });
+            (0, auth_1.setStrictNativeAuth)(cfg.strictNativeAuth === true);
+            if (!config.convexUrl) {
+                config.convexUrl = cfg.authConvexSiteUrl ?? auth_1.DEFAULT_CONVEX_SITE_URL;
+            }
+            maxErrors = cfg.maxCapturedErrors ?? 5;
+            errorBuffer = [];
+            return;
+        }
+        if (config.disableShakeGesture && (!config.quickIcon || config.quickIcon === 'auto')) {
+            config.quickIcon = 'always';
+        }
         firstShakeFired = false;
         // Route the in-SDK login screen to prod yaver.io by default; callers may
         // override for staging via authConvexSiteUrl / authWebBaseUrl.
@@ -129,12 +249,18 @@ class YaverFeedback {
         if (!config.convexUrl) {
             config.convexUrl = cfg.authConvexSiteUrl ?? auth_1.DEFAULT_CONVEX_SITE_URL;
         }
-        // Default: enabled only in dev mode
+        // Default: enabled. Pre-0.8.8 the SDK only enabled shake in dev
+        // builds (`__DEV__`), but apps that bundle the SDK explicitly *want*
+        // shake to work in TestFlight / Play Store builds — that's the
+        // primary use case (a tester finds a bug in a release build and
+        // shakes to report it). Dev builds get shake too. Apps that want
+        // to disable shake pass `enabled: false` (or
+        // `disableShakeGesture: true` for finer-grained control).
         if (cfg.enabled !== undefined) {
             enabled = cfg.enabled;
         }
         else {
-            enabled = typeof __DEV__ !== 'undefined' ? __DEV__ : false;
+            enabled = !cfg.disableShakeGesture;
         }
         // Hydrate cached auth token + preferred device from AsyncStorage so the
         // SDK reconnects silently on subsequent launches. If autoLogin is false
@@ -165,7 +291,7 @@ class YaverFeedback {
             shakeDetector.stop();
             shakeDetector = null;
         }
-        if (enabled && config.trigger === 'shake') {
+        if (enabled && config.trigger === 'shake' && !config.disableShakeGesture) {
             shakeDetector = new ShakeDetector_1.ShakeDetector();
             shakeDetector.start(() => {
                 YaverFeedback.notifyShake();
@@ -226,18 +352,40 @@ class YaverFeedback {
                     });
                 }
             });
-            // NOTE: BlackBox.start() is intentionally NOT auto-called here.
-            // An earlier version (0.7.6) did auto-start it, and when the
-            // agent was in bootstrap / needs-auth mode — which can happen
-            // any time after `yaver serve` restarts before the user pairs —
-            // the SSE channel retried with exponential backoff on 401s,
-            // producing a tight loop of string concatenation + JSON parse
-            // that tripped a Hermes rope-string SIGSEGV on iOS 18.3.1
-            // during any other JS-thread regex work (e.g. react-native-
-            // view-shot's internal string handling during Screenshot &
-            // Fix). Host apps call BlackBox.start() explicitly once they
-            // know the agent URL + token are valid (SFMG does this inside
-            // its YaverFeedbackWidget after auth).
+            // BlackBox auto-start (0.8.8+).
+            //
+            // 0.7.6 auto-started BlackBox immediately, which produced a
+            // Hermes rope-string SIGSEGV on iOS 18.3.1 when the agent was in
+            // bootstrap / needs-auth mode: the SSE channel retried with
+            // exponential backoff on 401s, generating a tight string-concat
+            // + JSON-parse loop that collided with react-native-view-shot's
+            // internal string handling during Screenshot & Fix. We rolled it
+            // back to manual-start (host calls BlackBox.start() after auth).
+            //
+            // The fix that lets us auto-start safely now:
+            //   1. Defer the start by 500ms so init() returns, the JS bridge
+            //      settles, and any first-launch auth-token round trip on
+            //      another thread completes before SSE opens.
+            //   2. Only start when we have BOTH an agentUrl AND an authToken
+            //      — without the token, the connect() call would 401 and we'd
+            //      reproduce the original loop.
+            //   3. Caller can opt out with cfg.autoStartBlackBox = false.
+            //
+            // SFMG used to call BlackBox.start() inside YaverFeedbackWidget
+            // after auth — that path still works (start() is idempotent), so
+            // upgrading SDK without removing the manual call is safe.
+            if (cfg.autoStartBlackBox !== false) {
+                setTimeout(() => {
+                    if (config?.agentUrl && (config?.authToken || p2pAuthToken)) {
+                        try {
+                            BlackBox_1.BlackBox.start();
+                        }
+                        catch (err) {
+                            console.warn('[YaverFeedback] BlackBox auto-start failed:', err);
+                        }
+                    }
+                }, 500);
+            }
         }
         // NOTE: We intentionally do NOT hook ErrorUtils.setGlobalHandler().
         // Sentry, Crashlytics, Bugsnag, and other tools all compete for that
@@ -552,7 +700,7 @@ class YaverFeedback {
                 BlackBox_1.BlackBox.start(); // restart with previous config
             }
             // Restart shake detector if trigger is 'shake'
-            if (config?.trigger === 'shake' && !shakeDetector) {
+            if (config?.trigger === 'shake' && !config?.disableShakeGesture && !shakeDetector) {
                 shakeDetector = new ShakeDetector_1.ShakeDetector();
                 shakeDetector.start(() => {
                     YaverFeedback.notifyShake();

package/dist/__tests__/AuthDevices.test.js

@@ -29,10 +29,10 @@ describe('auth device listing', () => {
                         platform: 'linux',
                         isOnline: true,
                         isGuest: true,
-                        hostName: 'Kivanc Cakmak',
-                        hostEmail: 'kivanc.cakmak@icloud.com',
+                        hostName: 'Host User',
+                        hostEmail: 'host@example.com',
                         accessScope: 'shared-scoped',
-                        quicHost: '157.180.114.179',
+                        quicHost: '198.51.100.20',
                         quicPort: 18080,
                         lastHeartbeat: 456,
                     },
@@ -49,7 +49,7 @@ describe('auth device listing', () => {
         expect(result.shared[0]).toMatchObject({
             deviceId: 'guest-1',
             isGuest: true,
-            hostEmail: 'kivanc.cakmak@icloud.com',
+            hostEmail: 'host@example.com',
             accessScope: 'shared-scoped',
         });
     });
@@ -64,10 +64,10 @@ describe('auth device listing', () => {
                         platform: 'linux',
                         isOnline: true,
                         isGuest: true,
-                        hostName: 'Kivanc Cakmak',
-                        hostEmail: 'kivanc.cakmak@icloud.com',
+                        hostName: 'Host User',
+                        hostEmail: 'host@example.com',
                         accessScope: 'shared-scoped',
-                        quicHost: '157.180.114.179',
+                        quicHost: '198.51.100.20',
                         quicPort: 18080,
                         lastHeartbeat: 789,
                     },

package/dist/__tests__/BlackBox.hotReload.test.d.ts

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

package/dist/__tests__/BlackBox.hotReload.test.js

@@ -0,0 +1,204 @@
+"use strict";
+// Hot-reload command-channel coverage for BlackBox.
+//
+// The agent uses BlackBox's SSE channel as a back-channel to push
+// "reload" / "reload_bundle" commands into a running guest app
+// (see desktop/agent/blackbox.go::BroadcastCommand). This test
+// pins the SDK's contract:
+//
+//   1. onCommand(handler) registers a handler and returns an
+//      unsubscribe function that actually unsubscribes.
+//   2. start() opens the SSE command-stream against the agent
+//      with the proper URL + headers.
+//   3. When the SSE stream delivers a JSON message of the form
+//      {type:"command", command:{command:"reload", data:...}},
+//      the registered handler fires with the inner command.
+//   4. start() also schedules the periodic flush — proving start
+//      is idempotent over multiple calls.
+Object.defineProperty(exports, "__esModule", { value: true });
+const BlackBox_1 = require("../BlackBox");
+const YaverFeedback_1 = require("../YaverFeedback");
+jest.mock('react-native', () => ({
+    Platform: { OS: 'ios' },
+}));
+// Drive Date.now / setTimeout deterministically.
+jest.useFakeTimers();
+const mockFetch = jest.fn();
+global.fetch = mockFetch;
+class MockAbortController {
+    constructor() {
+        this.signal = { aborted: false };
+        this.abort = jest.fn(() => {
+            this.signal.aborted = true;
+        });
+    }
+}
+global.AbortController = MockAbortController;
+// Helper to build an SSE streaming body.
+function sseBody(messages) {
+    const enc = new TextEncoder();
+    const chunks = messages.map((m) => `data: ${JSON.stringify(m)}\n\n`);
+    return new ReadableStream({
+        start(controller) {
+            for (const c of chunks)
+                controller.enqueue(enc.encode(c));
+            controller.close();
+        },
+    });
+}
+beforeEach(() => {
+    jest.clearAllMocks();
+    // Default: every POST (events) and the SSE GET both succeed.
+    mockFetch.mockImplementation((url) => {
+        if (url.includes('/blackbox/command-stream')) {
+            return Promise.resolve({
+                ok: true,
+                body: sseBody([]),
+            });
+        }
+        return Promise.resolve({
+            ok: true,
+            json: () => Promise.resolve({}),
+        });
+    });
+    YaverFeedback_1.YaverFeedback.init({
+        agentUrl: 'http://localhost:18080',
+        authToken: 'tok',
+    });
+});
+afterEach(() => {
+    BlackBox_1.BlackBox.stop();
+});
+describe('BlackBox hot-reload command channel', () => {
+    it('onCommand returns an unsubscribe that removes the handler', () => {
+        const a = jest.fn();
+        const b = jest.fn();
+        const offA = BlackBox_1.BlackBox.onCommand(a);
+        const offB = BlackBox_1.BlackBox.onCommand(b);
+        // Both subscribed — calling internal dispatch directly via the
+        // public surface isn't easy without SSE mockery, but
+        // deregistering should still leave only `b` registered after
+        // offA(), then no handlers after offB().
+        offA();
+        offB();
+        // Re-subscribe and confirm subscription returns a fresh unsub.
+        const offC = BlackBox_1.BlackBox.onCommand(jest.fn());
+        expect(typeof offC).toBe('function');
+        offC();
+    });
+    it('start() opens SSE against /blackbox/command-stream with bearer + device headers', async () => {
+        BlackBox_1.BlackBox.start({ deviceId: 'dev-abc', appName: 'sfmg' });
+        // Allow the async fetch in connectSSE to fire.
+        await Promise.resolve();
+        await Promise.resolve();
+        const sseCall = mockFetch.mock.calls.find(([url]) => String(url).includes('/blackbox/command-stream'));
+        expect(sseCall).toBeDefined();
+        const [url, init] = sseCall;
+        expect(String(url)).toContain('http://localhost:18080/blackbox/command-stream');
+        expect(String(url)).toContain('device=dev-abc');
+        expect(init.headers).toEqual(expect.objectContaining({
+            Authorization: 'Bearer tok',
+            Accept: 'text/event-stream',
+            'X-Device-ID': 'dev-abc',
+            'X-App-Name': 'sfmg',
+        }));
+    });
+    it('dispatches a {type:"command", command:{command:"reload"}} SSE frame to handlers', async () => {
+        // SSE body delivers one reload command, then closes.
+        mockFetch.mockImplementation((url) => {
+            if (url.includes('/blackbox/command-stream')) {
+                return Promise.resolve({
+                    ok: true,
+                    body: sseBody([
+                        { type: 'command', command: { command: 'reload', data: {} } },
+                    ]),
+                });
+            }
+            return Promise.resolve({ ok: true, json: () => Promise.resolve({}) });
+        });
+        const seen = [];
+        BlackBox_1.BlackBox.onCommand((cmd) => seen.push(cmd));
+        BlackBox_1.BlackBox.start({ deviceId: 'dev-1', appName: 'sfmg' });
+        // Drain the microtask + reader queue. The reader is async but
+        // the body is fully buffered + the stream closes immediately,
+        // so a few microtask flushes are enough.
+        for (let i = 0; i < 10; i++)
+            await Promise.resolve();
+        expect(seen).toEqual([
+            expect.objectContaining({ command: 'reload', data: {} }),
+        ]);
+    });
+    it('dispatches a reload_bundle command (carries bundleUrl payload)', async () => {
+        mockFetch.mockImplementation((url) => {
+            if (url.includes('/blackbox/command-stream')) {
+                return Promise.resolve({
+                    ok: true,
+                    body: sseBody([
+                        {
+                            type: 'command',
+                            command: {
+                                command: 'reload_bundle',
+                                data: { bundleUrl: '/dev/native-bundle' },
+                            },
+                        },
+                    ]),
+                });
+            }
+            return Promise.resolve({ ok: true, json: () => Promise.resolve({}) });
+        });
+        const seen = [];
+        BlackBox_1.BlackBox.onCommand((cmd) => seen.push(cmd));
+        BlackBox_1.BlackBox.start({ deviceId: 'dev-1', appName: 'sfmg' });
+        for (let i = 0; i < 10; i++)
+            await Promise.resolve();
+        expect(seen).toEqual([
+            expect.objectContaining({
+                command: 'reload_bundle',
+                data: expect.objectContaining({ bundleUrl: '/dev/native-bundle' }),
+            }),
+        ]);
+    });
+    it('handler exception does not break sibling handlers', async () => {
+        mockFetch.mockImplementation((url) => {
+            if (url.includes('/blackbox/command-stream')) {
+                return Promise.resolve({
+                    ok: true,
+                    body: sseBody([
+                        { type: 'command', command: { command: 'reload' } },
+                    ]),
+                });
+            }
+            return Promise.resolve({ ok: true, json: () => Promise.resolve({}) });
+        });
+        const sibling = jest.fn();
+        BlackBox_1.BlackBox.onCommand(() => {
+            throw new Error('caller bug — should not break the dispatch loop');
+        });
+        BlackBox_1.BlackBox.onCommand(sibling);
+        BlackBox_1.BlackBox.start({ deviceId: 'dev-1', appName: 'sfmg' });
+        for (let i = 0; i < 10; i++)
+            await Promise.resolve();
+        expect(sibling).toHaveBeenCalledWith(expect.objectContaining({ command: 'reload' }));
+    });
+    it('ignores non-command SSE frames (events/log/whatever)', async () => {
+        mockFetch.mockImplementation((url) => {
+            if (url.includes('/blackbox/command-stream')) {
+                return Promise.resolve({
+                    ok: true,
+                    body: sseBody([
+                        { type: 'log', logLine: 'hi' },
+                        { type: 'lifecycle', message: 'started' },
+                        { ping: 1 },
+                    ]),
+                });
+            }
+            return Promise.resolve({ ok: true, json: () => Promise.resolve({}) });
+        });
+        const handler = jest.fn();
+        BlackBox_1.BlackBox.onCommand(handler);
+        BlackBox_1.BlackBox.start({ deviceId: 'dev-1', appName: 'sfmg' });
+        for (let i = 0; i < 10; i++)
+            await Promise.resolve();
+        expect(handler).not.toHaveBeenCalled();
+    });
+});

package/dist/__tests__/P2PClient.test.js

@@ -195,5 +195,61 @@ describe('P2PClient', () => {
                 message: 'Reload request acknowledged. Agent is rebuilding the bundle.',
             }));
         });
+        it('dev mode hits /dev/reload with bearer auth', async () => {
+            mockFetch.mockResolvedValue({
+                ok: true,
+                json: () => Promise.resolve({ ok: true }),
+            });
+            const client = new P2PClient_1.P2PClient('http://localhost:18080', 'tok');
+            await client.reloadApp('dev');
+            expect(mockFetch).toHaveBeenCalledWith('http://localhost:18080/dev/reload', expect.objectContaining({
+                method: 'POST',
+                headers: expect.objectContaining({ Authorization: 'Bearer tok' }),
+            }));
+        });
+        it('bundle mode hits /dev/reload-app with mode + projectName in body', async () => {
+            mockFetch.mockResolvedValue({
+                ok: true,
+                json: () => Promise.resolve({ ok: true }),
+            });
+            const client = new P2PClient_1.P2PClient('http://localhost:18080', 'tok');
+            await client.reloadApp('bundle', { projectName: 'sfmg' });
+            const [url, init] = mockFetch.mock.calls[0];
+            expect(url).toBe('http://localhost:18080/dev/reload-app');
+            expect(init.method).toBe('POST');
+            expect(JSON.parse(init.body)).toEqual(expect.objectContaining({ mode: 'bundle', projectName: 'sfmg' }));
+            expect(init.headers).toEqual(expect.objectContaining({
+                Authorization: 'Bearer tok',
+                'Content-Type': 'application/json',
+            }));
+        });
+        it('dev mode falls back to /dev/reload-app when /dev/reload 4xxs', async () => {
+            // First call: /dev/reload 404. Second: /dev/reload-app 200.
+            mockFetch
+                .mockResolvedValueOnce({ ok: false, status: 404, json: () => Promise.resolve({}) })
+                .mockResolvedValueOnce({ ok: true, json: () => Promise.resolve({ ok: true }) });
+            const client = new P2PClient_1.P2PClient('http://localhost:18080', 'tok');
+            const result = await client.reloadApp('dev', { projectName: 'sfmg' });
+            expect(mockFetch).toHaveBeenCalledTimes(2);
+            expect(mockFetch.mock.calls[0][0]).toBe('http://localhost:18080/dev/reload');
+            expect(mockFetch.mock.calls[1][0]).toBe('http://localhost:18080/dev/reload-app');
+            expect(result.ok).toBe(true);
+        });
+        it('surfaces nativeChangesDetected so the host can prompt for rebuild', async () => {
+            mockFetch.mockResolvedValue({
+                ok: true,
+                json: () => Promise.resolve({
+                    ok: true,
+                    nativeChangesDetected: true,
+                    changeClass: 'native_required',
+                }),
+            });
+            const client = new P2PClient_1.P2PClient('http://localhost:18080', 'tok');
+            const result = await client.reloadApp('dev');
+            expect(result.nativeChangesDetected).toBe(true);
+            expect(result.changeClass).toBe('native_required');
+            // Caller-visible message must distinguish native-required from JS-only.
+            expect(result.message).toMatch(/native|rebuild/i);
+        });
     });
 });

package/dist/__tests__/YaverFeedback.test.js

@@ -76,6 +76,15 @@ describe('YaverFeedback', () => {
             expect(cfg.maxRecordingDuration).toBe(60);
             expect(cfg.strictNativeAuth).toBe(true);
         });
+        it('promotes quick icon to always when shake is disabled', () => {
+            YaverFeedback_1.YaverFeedback.init({
+                authToken: 'tok',
+                disableShakeGesture: true,
+            });
+            const cfg = YaverFeedback_1.YaverFeedback.getConfig();
+            expect(cfg.disableShakeGesture).toBe(true);
+            expect(cfg.quickIcon).toBe('always');
+        });
         it('with enabled=false sets enabled to false', () => {
             YaverFeedback_1.YaverFeedback.init({
                 authToken: 'tok',

package/dist/__tests__/types.test.js

@@ -17,11 +17,13 @@ describe('React Native SDK types', () => {
                 authToken: 'tok',
                 agentUrl: 'http://192.168.1.10:18080',
                 trigger: 'shake',
+                disableShakeGesture: true,
                 enabled: true,
                 maxRecordingDuration: 60,
                 strictNativeAuth: true,
             };
             expect(config.trigger).toBe('shake');
+            expect(config.disableShakeGesture).toBe(true);
             expect(config.strictNativeAuth).toBe(true);
         });
         it('accepts all trigger types', () => {