yaver-feedback-react-native 0.8.7 → 0.8.9

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);
     });
 

package/src/_core/constants.ts

@@ -57,9 +57,13 @@ export const DEFAULT_BEACON_UDP_PORT = 19837;
 /**
  * How old an agent's last heartbeat can be before the device is
  * considered offline. Mirrors `backend/convex/devices.ts` so
- * Convex + every client agree on the same threshold.
+ * Convex + every client agree on the same threshold. The agent
+ * heartbeats every 5 min (see `desktop/agent/main.go::heartbeatLoop`),
+ * so 6 min tolerates one missed beat + 60 s of jitter without
+ * flapping. Sub-minute death detection comes from the P2P bus, not
+ * this threshold.
  */
-export const HEARTBEAT_STALE_MS = 90_000;
+export const HEARTBEAT_STALE_MS = 360_000;
 
 /**
  * How long after the last UDP beacon an agent is still considered

package/src/types.ts

@@ -123,6 +123,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.