yaver-feedback-react-native 0.8.6 → 0.8.8

package/dist/types.d.ts

@@ -19,6 +19,61 @@ export interface RunnerBrowserAuthSession {
     updatedAt: number;
     completedAt?: number;
 }
+export interface IncidentEvent {
+    id: string;
+    timestamp: number;
+    severity: 'info' | 'warn' | 'error' | 'fatal';
+    category: string;
+    code: string;
+    source: string;
+    title: string;
+    userMessage: string;
+    technicalInfo?: string;
+    suggestedAction?: string;
+    operationId?: string;
+    deviceId?: string;
+    projectPath?: string;
+    target?: string;
+    logsAvailable: boolean;
+    logRefs?: string[];
+    correlationId?: string;
+    recoverable: boolean;
+    metadata?: Record<string, unknown>;
+    resolved?: boolean;
+}
+export interface OperationState {
+    id: string;
+    kind: string;
+    status: string;
+    phase?: string;
+    message?: string;
+    progress?: number;
+    deviceId?: string;
+    projectPath?: string;
+    startedAt: number;
+    updatedAt: number;
+    incidentIds?: string[];
+    metadata?: Record<string, unknown>;
+}
+export interface CapabilityTargetReadiness {
+    enabled: boolean;
+    reasonCode?: string;
+    reason?: string;
+    suggestedAction?: string;
+    notes?: string[];
+}
+export interface CapabilitySnapshot {
+    generatedAt: string;
+    machine?: Record<string, unknown>;
+    infra?: Record<string, unknown>;
+    connectivity?: {
+        directAvailable?: boolean;
+        relayConfigured?: boolean;
+        tunnelConfigured?: boolean;
+        tailscaleAvailable?: boolean;
+    };
+    targets: Record<string, CapabilityTargetReadiness>;
+}
 export interface FeedbackConfig {
     /** URL of the Yaver agent (e.g. "http://192.168.1.10:18080"). If omitted, auto-discovery is used. */
     agentUrl?: string;
@@ -63,6 +118,35 @@ export interface FeedbackConfig {
     preferredDeviceId?: string;
     /** How feedback collection is triggered */
     trigger?: 'shake' | 'floating-button' | 'manual';
+    /**
+     * Non-default escape hatch for host apps that want the SDK without
+     * shake gesture handling. When enabled:
+     * - the SDK does not start ShakeDetector
+     * - if `quickIcon` was left as `'auto'`/unset, it is promoted to `'always'`
+     * - the app should rely on the draggable quick icon or explicit
+     *   `YaverFeedback.startReport()` calls instead
+     *
+     * Intended for builds where another surface owns motion / haptics.
+     */
+    disableShakeGesture?: boolean;
+    /**
+     * Auto-open the BlackBox SSE command channel after init() returns.
+     *
+     * Default: `true` (0.8.8+). Listens for `reload`, `reload_bundle`,
+     * and `status` commands the agent broadcasts after a vibe-coding
+     * task commits a fix — drives the auto-reload loop without the host
+     * app needing to call `BlackBox.start()` manually.
+     *
+     * The auto-start is deferred 500ms after init() and gated on having
+     * BOTH `agentUrl` and `authToken` resolved, to avoid the iOS 18.3.1
+     * rope-string SIGSEGV that the early auto-start in 0.7.6 hit when
+     * the agent was in needs-auth mode (tight 401-retry loop in SSE).
+     *
+     * Set `false` if your host app wants to gate BlackBox start on its
+     * own state machine (e.g. only after the user opts into telemetry).
+     * Calling `BlackBox.start()` manually is still safe — it's idempotent.
+     */
+    autoStartBlackBox?: boolean;
     /**
      * Small tap-to-open icon that floats above the app so the user
      * doesn't have to shake every time they want to open feedback.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "yaver-feedback-react-native",
-  "version": "0.8.6",
+  "version": "0.8.8",
   "description": "Visual feedback SDK for Yaver \u2014 bug reports, screen recording, voice annotations, and local-first developer workflows",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/MachinePickerScreen.tsx

@@ -120,8 +120,8 @@ export const YaverMachinePickerScreen: React.FC<YaverMachinePickerProps> = ({
     // 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/src/P2PClient.ts

@@ -1,5 +1,13 @@
 import { Platform } from 'react-native';
-import { FeedbackBundle, RunnerBrowserAuthSession, TestSession, VoiceCapability } from './types';
+import {
+  CapabilitySnapshot,
+  FeedbackBundle,
+  IncidentEvent,
+  OperationState,
+  RunnerBrowserAuthSession,
+  TestSession,
+  VoiceCapability,
+} from './types';
 
 export interface FeedbackEvent {
   type: string;
@@ -191,6 +199,67 @@ export class P2PClient {
     try { await fetch(url, { method: 'POST', headers: this.authHeaders() }); } catch { /* best-effort */ }
   }
 
+  async capabilitySnapshot(): Promise<CapabilitySnapshot | null> {
+    try {
+      const resp = await fetch(`${this.baseUrl}/capabilities/snapshot`, { headers: this.authHeaders() });
+      if (!resp.ok) return null;
+      const data = await resp.json().catch(() => ({} as Record<string, unknown>));
+      return (data.snapshot ?? null) as CapabilitySnapshot | null;
+    } catch {
+      return null;
+    }
+  }
+
+  async incidents(opts: {
+    category?: string;
+    severity?: string;
+    code?: string;
+    deviceId?: string;
+    projectPath?: string;
+    includeResolved?: boolean;
+    limit?: number;
+  } = {}): Promise<IncidentEvent[]> {
+    try {
+      const url = new URL(`${this.baseUrl}/incidents`);
+      if (opts.category) url.searchParams.set('category', opts.category);
+      if (opts.severity) url.searchParams.set('severity', opts.severity);
+      if (opts.code) url.searchParams.set('code', opts.code);
+      if (opts.deviceId) url.searchParams.set('device', opts.deviceId);
+      if (opts.projectPath) url.searchParams.set('projectPath', opts.projectPath);
+      if (opts.includeResolved) url.searchParams.set('includeResolved', '1');
+      if (typeof opts.limit === 'number') url.searchParams.set('limit', String(opts.limit));
+      const resp = await fetch(url.toString(), { headers: this.authHeaders() });
+      if (!resp.ok) return [];
+      const data = await resp.json().catch(() => ({} as Record<string, unknown>));
+      return Array.isArray(data.incidents) ? (data.incidents as IncidentEvent[]) : [];
+    } catch {
+      return [];
+    }
+  }
+
+  async operations(opts: {
+    kind?: string;
+    status?: string;
+    deviceId?: string;
+    projectPath?: string;
+    limit?: number;
+  } = {}): Promise<OperationState[]> {
+    try {
+      const url = new URL(`${this.baseUrl}/operations`);
+      if (opts.kind) url.searchParams.set('kind', opts.kind);
+      if (opts.status) url.searchParams.set('status', opts.status);
+      if (opts.deviceId) url.searchParams.set('device', opts.deviceId);
+      if (opts.projectPath) url.searchParams.set('projectPath', opts.projectPath);
+      if (typeof opts.limit === 'number') url.searchParams.set('limit', String(opts.limit));
+      const resp = await fetch(url.toString(), { headers: this.authHeaders() });
+      if (!resp.ok) return [];
+      const data = await resp.json().catch(() => ({} as Record<string, unknown>));
+      return Array.isArray(data.operations) ? (data.operations as OperationState[]) : [];
+    } catch {
+      return [];
+    }
+  }
+
   /** Health check — returns true if the agent is reachable. */
   async health(): Promise<boolean> {
     try {

package/src/YaverFeedback.ts

@@ -137,6 +137,9 @@ export class YaverFeedback {
       autoLogin: true,
       ...cfg,
     };
+    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
@@ -155,11 +158,17 @@ export class YaverFeedback {
       config.convexUrl = cfg.authConvexSiteUrl ?? 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
@@ -193,7 +202,7 @@ export class YaverFeedback {
       shakeDetector.stop();
       shakeDetector = null;
     }
-    if (enabled && config.trigger === 'shake') {
+    if (enabled && config.trigger === 'shake' && !config.disableShakeGesture) {
       shakeDetector = new ShakeDetector();
       shakeDetector.start(() => {
         YaverFeedback.notifyShake();
@@ -253,18 +262,39 @@ export 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.start();
+            } catch (err) {
+              console.warn('[YaverFeedback] BlackBox auto-start failed:', err);
+            }
+          }
+        }, 500);
+      }
     }
 
     // NOTE: We intentionally do NOT hook ErrorUtils.setGlobalHandler().
@@ -583,7 +613,7 @@ export class YaverFeedback {
         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();
         shakeDetector.start(() => {
           YaverFeedback.notifyShake();

package/src/__tests__/AuthDevices.test.ts

@@ -31,10 +31,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,
             },
@@ -56,7 +56,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',
     });
   });
@@ -73,10 +73,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/src/__tests__/BlackBox.hotReload.test.ts

@@ -0,0 +1,226 @@
+// 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.
+
+import { BlackBox } from '../BlackBox';
+import { YaverFeedback } from '../YaverFeedback';
+
+jest.mock('react-native', () => ({
+  Platform: { OS: 'ios' },
+}));
+
+// Drive Date.now / setTimeout deterministically.
+jest.useFakeTimers();
+
+const mockFetch = jest.fn();
+global.fetch = mockFetch as any;
+
+class MockAbortController {
+  signal = { aborted: false };
+  abort = jest.fn(() => {
+    this.signal.aborted = true;
+  });
+}
+global.AbortController = MockAbortController as any;
+
+// Helper to build an SSE streaming body.
+function sseBody(messages: Array<unknown>): ReadableStream<Uint8Array> {
+  const enc = new TextEncoder();
+  const chunks = messages.map((m) => `data: ${JSON.stringify(m)}\n\n`);
+  return new ReadableStream<Uint8Array>({
+    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: string) => {
+    if (url.includes('/blackbox/command-stream')) {
+      return Promise.resolve({
+        ok: true,
+        body: sseBody([]),
+      });
+    }
+    return Promise.resolve({
+      ok: true,
+      json: () => Promise.resolve({}),
+    });
+  });
+  YaverFeedback.init({
+    agentUrl: 'http://localhost:18080',
+    authToken: 'tok',
+  });
+});
+
+afterEach(() => {
+  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.onCommand(a);
+    const offB = 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.onCommand(jest.fn());
+    expect(typeof offC).toBe('function');
+    offC();
+  });
+
+  it('start() opens SSE against /blackbox/command-stream with bearer + device headers', async () => {
+    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: string) => {
+      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: any[] = [];
+    BlackBox.onCommand((cmd) => seen.push(cmd));
+    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: string) => {
+      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: any[] = [];
+    BlackBox.onCommand((cmd) => seen.push(cmd));
+    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: string) => {
+      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.onCommand(() => {
+      throw new Error('caller bug — should not break the dispatch loop');
+    });
+    BlackBox.onCommand(sibling);
+
+    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: string) => {
+      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.onCommand(handler);
+    BlackBox.start({ deviceId: 'dev-1', appName: 'sfmg' });
+    for (let i = 0; i < 10; i++) await Promise.resolve();
+    expect(handler).not.toHaveBeenCalled();
+  });
+});

package/src/__tests__/P2PClient.test.ts

@@ -254,5 +254,75 @@ describe('P2PClient', () => {
         }),
       );
     });
+
+    it('dev mode hits /dev/reload with bearer auth', async () => {
+      mockFetch.mockResolvedValue({
+        ok: true,
+        json: () => Promise.resolve({ ok: true }),
+      });
+      const client = new 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('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 as string)).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('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('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/src/__tests__/YaverFeedback.test.ts

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

package/src/__tests__/types.test.ts

@@ -27,11 +27,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);
     });