yaver-feedback-react-native 0.9.0 → 0.9.3

package/src/__tests__/BlackBoxAutoStartColdStart.test.ts

@@ -0,0 +1,191 @@
+// BlackBox auto-start on a COLD start — the case that decides whether Hermes
+// hot reload works at all.
+//
+// The command channel that carries the agent's `reload_bundle` is BlackBox's
+// SSE stream. If BlackBox never starts, a fix pushed from the dev machine has
+// nowhere to land and the phone just sits there.
+//
+// Auto-start used to be a single 500ms timeout gated on `agentUrl && token`.
+// A real app passes NEITHER to init() — they're restored from storage — so on
+// a cold start the sequence is:
+//
+//     init() -> void hydrateSession()
+//                 -> AsyncStorage read (token)
+//                 -> AsyncStorage read (deviceId)
+//                 -> await discoverAgent()   <- Convex round trip + LAN probe
+//
+// which does not complete in 500ms. The one-shot check found no agentUrl, gave
+// up, and hot reload was silently dead until the user shook the device and
+// drove discovery by hand. These tests pin the retry that fixes it, and the
+// bounds that keep it from becoming a forever-poll or a 401 storm.
+
+import { BlackBox } from '../BlackBox';
+import { YaverFeedback } from '../YaverFeedback';
+
+jest.mock('react-native', () => ({
+  Platform: { OS: 'ios' },
+  DeviceEventEmitter: { emit: jest.fn(), addListener: jest.fn() },
+  NativeModules: {},
+}));
+
+jest.mock('../ShakeDetector', () => ({
+  ShakeDetector: jest.fn().mockImplementation(() => ({
+    start: jest.fn(),
+    stop: jest.fn(),
+  })),
+}));
+
+// Discovery is the slow step we're modelling. Resolves only after the test
+// flips `discovered`, standing in for "the Convex round trip finally landed".
+let discovered: string | null = null;
+jest.mock('../Discovery', () => ({
+  YaverDiscovery: {
+    discover: jest.fn(() =>
+      Promise.resolve(discovered ? { url: discovered } : null),
+    ),
+  },
+}));
+
+// The token cache hydrateSession() reads.
+let storedToken: string | null = null;
+jest.mock('../auth', () => ({
+  ...jest.requireActual('../auth'),
+  getToken: jest.fn(() => Promise.resolve(storedToken)),
+  getSelectedDeviceId: jest.fn(() => Promise.resolve(null)),
+  configureAuthEndpoints: jest.fn(),
+  setStrictNativeAuth: jest.fn(),
+}));
+
+jest.useFakeTimers();
+
+const mockFetch = jest.fn(() =>
+  Promise.resolve({ ok: true, json: () => Promise.resolve({}), body: null }),
+);
+
+class MockAbortController {
+  signal = { aborted: false };
+  abort = jest.fn();
+}
+
+// fetch and AbortController are process-globals, not per-file module state:
+// jest gives each test FILE its own module registry but they share one worker
+// process. Assigning them at module scope (as the sibling auto-start suite
+// does) leaves them mocked for every file that runs afterwards in the same
+// worker. Save and restore instead, so this suite can't be the reason some
+// unrelated file sees a stubbed fetch.
+const realFetch = global.fetch;
+const realAbortController = global.AbortController;
+
+beforeAll(() => {
+  global.fetch = mockFetch as any;
+  global.AbortController = MockAbortController as any;
+});
+
+afterAll(() => {
+  global.fetch = realFetch;
+  global.AbortController = realAbortController;
+  // Leave no timer chain behind for the next file in this worker.
+  YaverFeedback.destroy();
+  jest.useRealTimers();
+});
+
+beforeEach(() => {
+  jest.clearAllMocks();
+  discovered = null;
+  storedToken = null;
+  YaverFeedback.destroy();
+});
+
+afterEach(() => {
+  BlackBox.stop();
+  YaverFeedback.destroy();
+});
+
+describe('BlackBox auto-start on a cold start', () => {
+  it('starts once discovery resolves well after the old 500ms window', async () => {
+    const startSpy = jest.spyOn(BlackBox, 'start').mockImplementation(() => {});
+    storedToken = 'tok-from-storage';
+
+    // Nothing passed in — the real cold-start shape.
+    YaverFeedback.init({ trigger: 'shake', blackBox: { appName: 'talos-mobile' } });
+
+    // The window the old implementation checked, and only that window.
+    await jest.advanceTimersByTimeAsync(600);
+    expect(startSpy).not.toHaveBeenCalled();
+
+    // Discovery lands late, as it does on a real cold, off-LAN start.
+    discovered = 'http://10.0.0.5:18080';
+    await jest.advanceTimersByTimeAsync(4000);
+
+    expect(startSpy).toHaveBeenCalledWith(
+      expect.objectContaining({ appName: 'talos-mobile' }),
+    );
+    startSpy.mockRestore();
+  });
+
+  it('never starts without a token, however long it waits', async () => {
+    // The guard that matters: starting tokenless makes the SSE channel 401 and
+    // retry with backoff — the string-concat + JSON-parse loop that SIGSEGV'd
+    // Hermes on iOS 18.3.1. Retrying must not erode it.
+    const startSpy = jest.spyOn(BlackBox, 'start').mockImplementation(() => {});
+    storedToken = null;
+    discovered = 'http://10.0.0.5:18080';
+
+    YaverFeedback.init({ trigger: 'shake' });
+    await jest.advanceTimersByTimeAsync(90_000);
+
+    expect(startSpy).not.toHaveBeenCalled();
+    startSpy.mockRestore();
+  });
+
+  it('gives up rather than polling forever', async () => {
+    const startSpy = jest.spyOn(BlackBox, 'start').mockImplementation(() => {});
+    storedToken = null;
+
+    YaverFeedback.init({ trigger: 'shake' });
+    // Past the ~60s bound.
+    await jest.advanceTimersByTimeAsync(90_000);
+
+    // Credentials arrive after the window closed — the poll is done.
+    storedToken = 'late';
+    discovered = 'http://10.0.0.5:18080';
+    await jest.advanceTimersByTimeAsync(10_000);
+
+    expect(startSpy).not.toHaveBeenCalled();
+    startSpy.mockRestore();
+  });
+
+  it('signing in re-arms after the bound has passed', async () => {
+    // Giving up is only acceptable because this path exists: a user who signs
+    // in later gets the channel without restarting the app.
+    const startSpy = jest.spyOn(BlackBox, 'start').mockImplementation(() => {});
+
+    YaverFeedback.init({ trigger: 'shake' });
+    await jest.advanceTimersByTimeAsync(90_000);
+    expect(startSpy).not.toHaveBeenCalled();
+
+    discovered = 'http://10.0.0.5:18080';
+    await YaverFeedback.setAuthToken('tok-from-login');
+    await jest.advanceTimersByTimeAsync(2000);
+
+    expect(startSpy).toHaveBeenCalled();
+    startSpy.mockRestore();
+  });
+
+  it('destroy() cancels a pending retry', async () => {
+    // A retry chain firing against a torn-down config would start the recorder
+    // for an SDK the host believes is off.
+    const startSpy = jest.spyOn(BlackBox, 'start').mockImplementation(() => {});
+    storedToken = 'tok';
+
+    YaverFeedback.init({ trigger: 'shake' });
+    await jest.advanceTimersByTimeAsync(600);
+
+    YaverFeedback.destroy();
+    discovered = 'http://10.0.0.5:18080';
+    await jest.advanceTimersByTimeAsync(10_000);
+
+    expect(startSpy).not.toHaveBeenCalled();
+    startSpy.mockRestore();
+  });
+});

package/src/__tests__/BrowserLaneIcon.test.ts

@@ -0,0 +1,85 @@
+/**
+ * Browser-lane DOM icon (feedback-sdk-lanes audit 2026-07-28). RN-web inside
+ * Yaver's fullScreen preview WebView: native shake can't fire and the container
+ * overlay is occluded, so the SDK mounts an occlusion-proof DOM icon. Node env,
+ * so we stub Platform.OS='web' + a minimal DOM.
+ */
+jest.mock('react-native', () => ({
+  Platform: { OS: 'web' },
+  NativeModules: {},
+}));
+
+// Minimal DOM stub — enough for mountBrowserLaneIcon's createElement/appendChild.
+function installFakeDom() {
+  const els: Record<string, any> = {};
+  const makeEl = () => ({
+    id: '',
+    textContent: '',
+    title: '',
+    style: {} as Record<string, string>,
+    _handlers: {} as Record<string, unknown>,
+    setAttribute() {},
+    setPointerCapture() {},
+    releasePointerCapture() {},
+    getBoundingClientRect: () => ({ left: 0, top: 0, width: 44, height: 44 }),
+    addEventListener(k: string, fn: unknown) { this._handlers[k] = fn; },
+  });
+  (globalThis as any).window = {
+    innerWidth: 390, innerHeight: 844,
+    addEventListener() {},
+    __yaverLane: 'browser',
+  };
+  (globalThis as any).localStorage = { getItem: () => null, setItem() {} };
+  (globalThis as any).document = {
+    body: { appendChild(el: any) { els[el.id] = el; } },
+    getElementById: (id: string) => els[id] || null,
+    createElement: () => makeEl(),
+  };
+  return { els };
+}
+
+describe('RN SDK browser-lane icon', () => {
+  afterEach(() => {
+    delete (globalThis as any).window;
+    delete (globalThis as any).document;
+    delete (globalThis as any).localStorage;
+    jest.resetModules();
+  });
+
+  it('detectWebLane reads window.__yaverLane on web', () => {
+    installFakeDom();
+    const { YaverFeedback } = require('../YaverFeedback');
+    expect(YaverFeedback.detectWebLane()).toBe('browser');
+  });
+
+  it('mounts a fixed, max-z-index, draggable DOM icon in the browser lane', () => {
+    const { els } = installFakeDom();
+    const { YaverFeedback } = require('../YaverFeedback');
+    YaverFeedback.mountBrowserLaneIcon();
+    const btn = els['yaver-feedback-btn'];
+    expect(btn).toBeTruthy();
+    expect(btn.textContent).toBe('Y');
+    expect(btn.style.cssText).toContain('position:fixed');
+    expect(btn.style.cssText).toContain('z-index:99999');
+    // Draggable: pointer handlers wired.
+    expect(typeof btn._handlers['pointerdown']).toBe('function');
+    expect(typeof btn._handlers['pointerup']).toBe('function');
+  });
+
+  it('is idempotent — a second mount does not stack a second icon', () => {
+    const { els } = installFakeDom();
+    const { YaverFeedback } = require('../YaverFeedback');
+    YaverFeedback.mountBrowserLaneIcon();
+    const first = els['yaver-feedback-btn'];
+    YaverFeedback.mountBrowserLaneIcon();
+    expect(els['yaver-feedback-btn']).toBe(first);
+  });
+
+  it('no-ops when not in a browser lane', () => {
+    const { els } = installFakeDom();
+    (globalThis as any).window.__yaverLane = undefined;
+    const { YaverFeedback } = require('../YaverFeedback');
+    YaverFeedback.mountBrowserLaneIcon();
+    expect(els['yaver-feedback-btn']).toBeUndefined();
+  });
+});

package/src/__tests__/DogfoodRuntime.test.ts

@@ -0,0 +1,135 @@
+import {
+  DogfoodController,
+  DogfoodRuntimeError,
+  defaultDogfoodLane,
+  dogfoodLaneOptions,
+  dogfoodLogLinesFromDevEvent,
+  validateDogfoodProject,
+  type DogfoodDriver,
+  type DogfoodProject,
+} from '../DogfoodRuntime';
+
+const expo: DogfoodProject = {
+  name: 'Example', workDir: '/workspace/example', framework: 'expo', lane: 'browser',
+};
+
+describe('DogfoodController', () => {
+  test('does no work before the explicit trigger', () => {
+    const driver: DogfoodDriver = { start: jest.fn(async () => ({ lane: 'browser' as const })) };
+    const controller = new DogfoodController(expo, driver);
+    expect(driver.start).not.toHaveBeenCalled();
+    expect(controller.snapshot().phase).toBe('idle');
+  });
+
+  test('preserves raw npm output and hands a live session to the host', async () => {
+    const stop = jest.fn();
+    const closeLogs = jest.fn();
+    const controller = new DogfoodController(expo, {
+      async start(ctx) {
+        ctx.registerCleanup(stop, 'session');
+        ctx.registerCleanup(closeLogs, 'transient');
+        ctx.log('$ npm install --legacy-peer-deps');
+        ctx.log('npm warn deprecated example@1.0.0');
+        return { lane: 'browser', sessionId: 's1', url: 'http://agent/dev/' };
+      },
+    });
+
+    await controller.trigger();
+    expect(controller.snapshot().logs.map((line) => line.text)).toEqual([
+      '$ npm install --legacy-peer-deps',
+      'npm warn deprecated example@1.0.0',
+    ]);
+    expect(await controller.handoff()).toMatchObject({ sessionId: 's1' });
+    expect(closeLogs).toHaveBeenCalledTimes(1);
+    expect(stop).not.toHaveBeenCalled();
+  });
+
+  test('cleans a partial session before exposing a structured failure', async () => {
+    const stop = jest.fn();
+    const controller = new DogfoodController(expo, {
+      async start(ctx) {
+        ctx.registerCleanup(stop);
+        throw new DogfoodRuntimeError({
+          code: 'DOGFOOD_RENDER_FAILED', error: 'Metro exited', remedy: 'Fix Metro and retry.', retryable: true,
+        });
+      },
+    });
+    await expect(controller.trigger()).rejects.toThrow('Metro exited');
+    expect(stop).toHaveBeenCalledTimes(1);
+    expect(controller.snapshot()).toMatchObject({ phase: 'failed', failure: { code: 'DOGFOOD_RENDER_FAILED' } });
+  });
+
+  test('an obsolete attempt cannot clean up the replacement attempt', async () => {
+    let releaseFirst!: () => void;
+    const firstGate = new Promise<void>((resolve) => { releaseFirst = resolve; });
+    let firstStarted!: () => void;
+    const firstStartedGate = new Promise<void>((resolve) => { firstStarted = resolve; });
+    const stopFirst = jest.fn();
+    const stopSecond = jest.fn();
+    let starts = 0;
+    const controller = new DogfoodController(expo, {
+      async start(ctx) {
+        starts += 1;
+        if (starts === 1) {
+          ctx.registerCleanup(stopFirst);
+          firstStarted();
+          await firstGate;
+          return { lane: 'browser', sessionId: 'old' };
+        }
+        ctx.registerCleanup(stopSecond);
+        return { lane: 'browser', sessionId: 'new' };
+      },
+    });
+
+    const old = controller.trigger();
+    await firstStartedGate;
+    await controller.stop();
+    await expect(controller.trigger()).resolves.toMatchObject({ sessionId: 'new' });
+    releaseFirst();
+    await expect(old).rejects.toMatchObject({ failure: { code: 'DOGFOOD_ATTEMPT_REPLACED' } });
+    expect(stopFirst).toHaveBeenCalledTimes(1);
+    expect(stopSecond).not.toHaveBeenCalled();
+    await controller.stop();
+    expect(stopSecond).toHaveBeenCalledTimes(1);
+  });
+});
+
+describe('Dogfood lanes and console events', () => {
+  test('Flutter is first-class on browser but cannot be mislabeled Hermes', () => {
+    expect(validateDogfoodProject({ ...expo, framework: 'flutter', lane: 'browser' })).toBeNull();
+    expect(validateDogfoodProject({ ...expo, framework: 'flutter', lane: 'hermes' })?.code)
+      .toBe('DOGFOOD_HERMES_FRAMEWORK_UNSUPPORTED');
+  });
+
+  test('uses one three-lane matrix with browser default for React Native and Flutter', () => {
+    const rn = dogfoodLaneOptions('expo', { nativeRuntimeAvailable: true });
+    expect(defaultDogfoodLane('expo')).toBe('browser');
+    expect(rn.map((option) => [option.lane, option.supported])).toEqual([
+      ['browser', true], ['hermes', true], ['webrtc', true],
+    ]);
+    const flutter = dogfoodLaneOptions('flutter', { nativeRuntimeAvailable: true });
+    expect(defaultDogfoodLane('flutter')).toBe('browser');
+    expect(flutter.find((option) => option.lane === 'hermes')?.supported).toBe(false);
+  });
+
+  test('keeps Yaver self-development on the same RN three-lane contract', () => {
+    const options = dogfoodLaneOptions('expo', { nativeRuntimeAvailable: true, selfDevelopment: true });
+    expect(options).toHaveLength(3);
+    expect(options.find((option) => option.lane === 'hermes')).toMatchObject({ supported: true });
+    expect(options.find((option) => option.lane === 'webrtc')).toMatchObject({ supported: true });
+  });
+
+  test('native-only projects use WebRTC rather than fake browser or Hermes lanes', () => {
+    const swift = dogfoodLaneOptions('swift', { nativeRuntimeAvailable: true });
+    expect(swift.map((option) => [option.lane, option.supported])).toEqual([
+      ['browser', false], ['hermes', false], ['webrtc', true],
+    ]);
+  });
+
+  test('reads raw and replayed package-manager logs from /dev/events', () => {
+    expect(dogfoodLogLinesFromDevEvent({ type: 'log', logLine: '$ npm ci\u001b[0m' }))
+      .toEqual(['$ npm ci\u001b[0m']);
+    expect(dogfoodLogLinesFromDevEvent({ type: 'snapshot', snapshot: { recentLogs: ['npm warn x', 'Metro ready'] } }))
+      .toEqual(['npm warn x', 'Metro ready']);
+  });
+});

package/src/__tests__/P2PClient.test.ts

@@ -159,7 +159,7 @@ describe('P2PClient', () => {
       const bundle = {
         metadata: {
           timestamp: '2026-03-24T00:00:00Z',
-          device: {
+          deviceInfo: {
             platform: 'ios',
             osVersion: '18.0',
             model: 'iPhone 16',
@@ -191,7 +191,7 @@ describe('P2PClient', () => {
       const bundle = {
         metadata: {
           timestamp: '2026-03-24T00:00:00Z',
-          device: { platform: 'ios', osVersion: '18', model: 'iPhone', screenWidth: 393, screenHeight: 852 },
+          deviceInfo: { platform: 'ios', osVersion: '18', model: 'iPhone', screenWidth: 393, screenHeight: 852 },
           app: {},
         },
         screenshots: [],

package/src/__tests__/P2PDogfoodDriver.test.ts

@@ -0,0 +1,80 @@
+import { DogfoodController } from '../DogfoodRuntime';
+import { createP2PDogfoodDriver } from '../P2PDogfoodDriver';
+import type { P2PClient } from '../P2PClient';
+
+describe('createP2PDogfoodDriver', () => {
+  it('keeps the browser lane compiling until the ordinary Projects status reports a URL', async () => {
+    const stop = jest.fn(async () => {});
+    const status = jest.fn()
+      .mockResolvedValueOnce({ building: true, framework: 'flutter' })
+      .mockResolvedValueOnce({ running: true, serving: true, framework: 'flutter', bundleUrl: '/dev/' });
+    const client = {
+      subscribeDogfoodDevEvents: (onEvent: (event: unknown) => void) => {
+        onEvent({ type: 'log', logLine: '$ flutter run -d web-server' });
+        return jest.fn();
+      },
+      startDogfoodDevServer: jest.fn(async () => ({ starting: true, framework: 'flutter' })),
+      getDogfoodDevServerStatus: status,
+      stopDogfoodDevServer: stop,
+      resolveDogfoodUrl: (path: string) => `http://agent.test${path}`,
+    } as unknown as P2PClient;
+    const snapshots: string[][] = [];
+    const controller = new DogfoodController(
+      { name: 'Flutter app', framework: 'flutter', workDir: '/workspace/app', lane: 'browser' },
+      createP2PDogfoodDriver(client, { pollIntervalMs: 1, startupTimeoutMs: 100 }),
+      { onChange: (snapshot) => snapshots.push(snapshot.logs.map((line) => line.text)) },
+    );
+
+    const result = await controller.trigger();
+
+    expect(result.url).toBe('http://agent.test/dev/');
+    expect(status).toHaveBeenCalledTimes(2);
+    expect(snapshots.flat()).toContain('$ flutter run -d web-server');
+    expect(stop).not.toHaveBeenCalled();
+    await controller.stop();
+    expect(stop).toHaveBeenCalledTimes(1);
+  });
+
+  it('starts and cleans up an available native WebRTC runtime', async () => {
+    const closeRuntime = jest.fn(async () => {});
+    const client = {
+      subscribeDogfoodDevEvents: () => jest.fn(),
+      getDogfoodRemoteRuntimeCapabilities: jest.fn(async () => ({
+        targets: [
+          { id: 'browser-window', label: 'Browser', enabled: true },
+          { id: 'ios-simulator', label: 'iPhone simulator', enabled: true },
+        ],
+      })),
+      startDogfoodRemoteRuntime: jest.fn(async () => ({
+        id: 'runtime-1', status: 'starting', targetId: 'ios-simulator',
+      })),
+      stopDogfoodRemoteRuntime: closeRuntime,
+    } as unknown as P2PClient;
+    const controller = new DogfoodController(
+      { name: 'Native app', framework: 'flutter', workDir: '/workspace/app', lane: 'webrtc' },
+      createP2PDogfoodDriver(client),
+    );
+
+    await expect(controller.trigger()).resolves.toMatchObject({ lane: 'webrtc', sessionId: 'runtime-1' });
+    expect(closeRuntime).not.toHaveBeenCalled();
+    await controller.stop();
+    expect(closeRuntime).toHaveBeenCalledWith('runtime-1');
+  });
+
+  it('delivers Hermes without stopping an unrelated dev server on exit', async () => {
+    const stop = jest.fn(async () => {});
+    const client = {
+      subscribeDogfoodDevEvents: () => jest.fn(),
+      startDogfoodDevServer: jest.fn(async () => ({ running: true, framework: 'expo', workDir: '/workspace/app' })),
+      stopDogfoodDevServer: stop,
+    } as unknown as P2PClient;
+    const controller = new DogfoodController(
+      { name: 'RN app', framework: 'expo', workDir: '/workspace/app', lane: 'hermes' },
+      createP2PDogfoodDriver(client),
+    );
+
+    await expect(controller.trigger()).resolves.toMatchObject({ lane: 'hermes', metadata: { delivered: true } });
+    await controller.stop();
+    expect(stop).not.toHaveBeenCalled();
+  });
+});