yaver-feedback-react-native 0.9.0 → 0.9.3

package/dist/__tests__/BlackBoxAutoStartColdStart.test.js

@@ -0,0 +1,156 @@
+"use strict";
+// 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.
+Object.defineProperty(exports, "__esModule", { value: true });
+const BlackBox_1 = require("../BlackBox");
+const YaverFeedback_1 = require("../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 = null;
+jest.mock('../Discovery', () => ({
+    YaverDiscovery: {
+        discover: jest.fn(() => Promise.resolve(discovered ? { url: discovered } : null)),
+    },
+}));
+// The token cache hydrateSession() reads.
+let storedToken = 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 {
+    constructor() {
+        this.signal = { aborted: false };
+        this.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;
+    global.AbortController = MockAbortController;
+});
+afterAll(() => {
+    global.fetch = realFetch;
+    global.AbortController = realAbortController;
+    // Leave no timer chain behind for the next file in this worker.
+    YaverFeedback_1.YaverFeedback.destroy();
+    jest.useRealTimers();
+});
+beforeEach(() => {
+    jest.clearAllMocks();
+    discovered = null;
+    storedToken = null;
+    YaverFeedback_1.YaverFeedback.destroy();
+});
+afterEach(() => {
+    BlackBox_1.BlackBox.stop();
+    YaverFeedback_1.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_1.BlackBox, 'start').mockImplementation(() => { });
+        storedToken = 'tok-from-storage';
+        // Nothing passed in — the real cold-start shape.
+        YaverFeedback_1.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_1.BlackBox, 'start').mockImplementation(() => { });
+        storedToken = null;
+        discovered = 'http://10.0.0.5:18080';
+        YaverFeedback_1.YaverFeedback.init({ trigger: 'shake' });
+        await jest.advanceTimersByTimeAsync(90000);
+        expect(startSpy).not.toHaveBeenCalled();
+        startSpy.mockRestore();
+    });
+    it('gives up rather than polling forever', async () => {
+        const startSpy = jest.spyOn(BlackBox_1.BlackBox, 'start').mockImplementation(() => { });
+        storedToken = null;
+        YaverFeedback_1.YaverFeedback.init({ trigger: 'shake' });
+        // Past the ~60s bound.
+        await jest.advanceTimersByTimeAsync(90000);
+        // Credentials arrive after the window closed — the poll is done.
+        storedToken = 'late';
+        discovered = 'http://10.0.0.5:18080';
+        await jest.advanceTimersByTimeAsync(10000);
+        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_1.BlackBox, 'start').mockImplementation(() => { });
+        YaverFeedback_1.YaverFeedback.init({ trigger: 'shake' });
+        await jest.advanceTimersByTimeAsync(90000);
+        expect(startSpy).not.toHaveBeenCalled();
+        discovered = 'http://10.0.0.5:18080';
+        await YaverFeedback_1.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_1.BlackBox, 'start').mockImplementation(() => { });
+        storedToken = 'tok';
+        YaverFeedback_1.YaverFeedback.init({ trigger: 'shake' });
+        await jest.advanceTimersByTimeAsync(600);
+        YaverFeedback_1.YaverFeedback.destroy();
+        discovered = 'http://10.0.0.5:18080';
+        await jest.advanceTimersByTimeAsync(10000);
+        expect(startSpy).not.toHaveBeenCalled();
+        startSpy.mockRestore();
+    });
+});

package/dist/__tests__/BrowserLaneIcon.test.d.ts

@@ -0,0 +1,3 @@
+declare function installFakeDom(): {
+    els: Record<string, any>;
+};

package/dist/__tests__/BrowserLaneIcon.test.js

@@ -0,0 +1,80 @@
+"use strict";
+/**
+ * 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 = {};
+    const makeEl = () => ({
+        id: '',
+        textContent: '',
+        title: '',
+        style: {},
+        _handlers: {},
+        setAttribute() { },
+        setPointerCapture() { },
+        releasePointerCapture() { },
+        getBoundingClientRect: () => ({ left: 0, top: 0, width: 44, height: 44 }),
+        addEventListener(k, fn) { this._handlers[k] = fn; },
+    });
+    globalThis.window = {
+        innerWidth: 390, innerHeight: 844,
+        addEventListener() { },
+        __yaverLane: 'browser',
+    };
+    globalThis.localStorage = { getItem: () => null, setItem() { } };
+    globalThis.document = {
+        body: { appendChild(el) { els[el.id] = el; } },
+        getElementById: (id) => els[id] || null,
+        createElement: () => makeEl(),
+    };
+    return { els };
+}
+describe('RN SDK browser-lane icon', () => {
+    afterEach(() => {
+        delete globalThis.window;
+        delete globalThis.document;
+        delete globalThis.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.window.__yaverLane = undefined;
+        const { YaverFeedback } = require('../YaverFeedback');
+        YaverFeedback.mountBrowserLaneIcon();
+        expect(els['yaver-feedback-btn']).toBeUndefined();
+    });
+});

package/dist/__tests__/DogfoodRuntime.test.d.ts

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

package/dist/__tests__/DogfoodRuntime.test.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const DogfoodRuntime_1 = require("../DogfoodRuntime");
+const expo = {
+    name: 'Example', workDir: '/workspace/example', framework: 'expo', lane: 'browser',
+};
+describe('DogfoodController', () => {
+    test('does no work before the explicit trigger', () => {
+        const driver = { start: jest.fn(async () => ({ lane: 'browser' })) };
+        const controller = new DogfoodRuntime_1.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 DogfoodRuntime_1.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 DogfoodRuntime_1.DogfoodController(expo, {
+            async start(ctx) {
+                ctx.registerCleanup(stop);
+                throw new DogfoodRuntime_1.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;
+        const firstGate = new Promise((resolve) => { releaseFirst = resolve; });
+        let firstStarted;
+        const firstStartedGate = new Promise((resolve) => { firstStarted = resolve; });
+        const stopFirst = jest.fn();
+        const stopSecond = jest.fn();
+        let starts = 0;
+        const controller = new DogfoodRuntime_1.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((0, DogfoodRuntime_1.validateDogfoodProject)({ ...expo, framework: 'flutter', lane: 'browser' })).toBeNull();
+        expect((0, DogfoodRuntime_1.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 = (0, DogfoodRuntime_1.dogfoodLaneOptions)('expo', { nativeRuntimeAvailable: true });
+        expect((0, DogfoodRuntime_1.defaultDogfoodLane)('expo')).toBe('browser');
+        expect(rn.map((option) => [option.lane, option.supported])).toEqual([
+            ['browser', true], ['hermes', true], ['webrtc', true],
+        ]);
+        const flutter = (0, DogfoodRuntime_1.dogfoodLaneOptions)('flutter', { nativeRuntimeAvailable: true });
+        expect((0, DogfoodRuntime_1.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 = (0, DogfoodRuntime_1.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 = (0, DogfoodRuntime_1.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((0, DogfoodRuntime_1.dogfoodLogLinesFromDevEvent)({ type: 'log', logLine: '$ npm ci\u001b[0m' }))
+            .toEqual(['$ npm ci\u001b[0m']);
+        expect((0, DogfoodRuntime_1.dogfoodLogLinesFromDevEvent)({ type: 'snapshot', snapshot: { recentLogs: ['npm warn x', 'Metro ready'] } }))
+            .toEqual(['npm warn x', 'Metro ready']);
+    });
+});

package/dist/__tests__/P2PClient.test.js

@@ -119,7 +119,7 @@ describe('P2PClient', () => {
             const bundle = {
                 metadata: {
                     timestamp: '2026-03-24T00:00:00Z',
-                    device: {
+                    deviceInfo: {
                         platform: 'ios',
                         osVersion: '18.0',
                         model: 'iPhone 16',
@@ -145,7 +145,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/dist/__tests__/P2PDogfoodDriver.test.d.ts

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

package/dist/__tests__/P2PDogfoodDriver.test.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const DogfoodRuntime_1 = require("../DogfoodRuntime");
+const P2PDogfoodDriver_1 = require("../P2PDogfoodDriver");
+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) => {
+                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) => `http://agent.test${path}`,
+        };
+        const snapshots = [];
+        const controller = new DogfoodRuntime_1.DogfoodController({ name: 'Flutter app', framework: 'flutter', workDir: '/workspace/app', lane: 'browser' }, (0, P2PDogfoodDriver_1.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,
+        };
+        const controller = new DogfoodRuntime_1.DogfoodController({ name: 'Native app', framework: 'flutter', workDir: '/workspace/app', lane: 'webrtc' }, (0, P2PDogfoodDriver_1.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,
+        };
+        const controller = new DogfoodRuntime_1.DogfoodController({ name: 'RN app', framework: 'expo', workDir: '/workspace/app', lane: 'hermes' }, (0, P2PDogfoodDriver_1.createP2PDogfoodDriver)(client));
+        await expect(controller.trigger()).resolves.toMatchObject({ lane: 'hermes', metadata: { delivered: true } });
+        await controller.stop();
+        expect(stop).not.toHaveBeenCalled();
+    });
+});

package/dist/__tests__/ReportIdentity.test.d.ts

@@ -0,0 +1,25 @@
+declare const mockReactNative: {
+    Platform: {
+        OS: string;
+    };
+    NativeModules: {};
+};
+declare const mockExpoModule: {
+    default: Record<string, unknown>;
+};
+/** Mirrors mobile/app.json in the Talos repo — the SDK's first external consumer. */
+declare const EXPO_CONFIG: {
+    name: string;
+    slug: string;
+    version: string;
+    ios: {
+        bundleIdentifier: string;
+        buildNumber: string;
+    };
+    android: {
+        package: string;
+        versionCode: number;
+    };
+};
+declare function mockExpoConstants(expoConfig: unknown, extra?: Record<string, unknown>): void;
+declare function loadResolve(): typeof import('../P2PClient').resolveReportIdentity;

package/dist/__tests__/ReportIdentity.test.js

@@ -0,0 +1,180 @@
+"use strict";
+// resolveAppIdentity() has always fed /vibing/execute and /dev/reload-app so
+// the agent could route "vibe on THIS app" to the right repo, but nothing fed
+// /feedback — reports carried no identity at all, so the agent's fix router
+// had nothing to resolve and fell back to whatever directory it was sitting
+// in. resolveReportIdentity() closes that gap for the feedback path.
+const mockReactNative = {
+    Platform: { OS: 'ios' },
+    NativeModules: {},
+};
+const mockExpoModule = { default: {} };
+jest.mock('react-native', () => mockReactNative);
+jest.mock('expo-constants', () => mockExpoModule, { virtual: true });
+/** Mirrors mobile/app.json in the Talos repo — the SDK's first external consumer. */
+const EXPO_CONFIG = {
+    name: 'Talos',
+    slug: 'talos-mobile',
+    version: '1.9.157',
+    ios: { bundleIdentifier: 'works.talos.mobile', buildNumber: '427' },
+    android: { package: 'works.talos.mobile', versionCode: 423 },
+};
+function mockExpoConstants(expoConfig, extra = {}) {
+    mockExpoModule.default = { expoConfig, ...extra };
+}
+function loadResolve() {
+    let resolve;
+    jest.isolateModules(() => {
+        jest.doMock('react-native', () => mockReactNative);
+        jest.doMock('expo-constants', () => mockExpoModule, { virtual: true });
+        resolve = require('../P2PClient').resolveReportIdentity;
+    });
+    return resolve;
+}
+beforeEach(() => {
+    // P2PClient is imported by many suites with different virtual RN/Expo
+    // modules. Re-evaluate it against this suite's mutable modules every time;
+    // an order-dependent green test is not an identity-routing guard.
+    jest.resetModules();
+    mockReactNative.Platform.OS = 'ios';
+    mockReactNative.NativeModules = {};
+    mockExpoModule.default = {};
+});
+describe('resolveReportIdentity', () => {
+    it('resolves app name and bundle id from the Expo config', () => {
+        mockExpoConstants(EXPO_CONFIG);
+        const resolve = loadResolve();
+        const identity = resolve();
+        // The agent's fix router reads DeviceInfo.AppName first.
+        expect(identity.appName).toBe('Talos');
+        // ...and resolves the project by bundle id, the only unambiguous key.
+        expect(identity.project?.bundleId).toBe('works.talos.mobile');
+        expect(identity.project?.projectName).toBe('Talos');
+        expect(identity.project?.appName).toBe('Talos');
+        expect(identity.project?.surface).toBe('mobile');
+        expect(identity.app.bundleId).toBe('works.talos.mobile');
+    });
+    it('never reports a project path', () => {
+        mockExpoConstants(EXPO_CONFIG);
+        const resolve = loadResolve();
+        // The agent ignores client-supplied paths on feedback reports (an
+        // untrusted guest could otherwise aim the fix task's CWD at ~/.ssh).
+        // Sending one would be misleading at best.
+        expect(resolve().project?.projectPath).toBeUndefined();
+    });
+    it('prefers the native runtime version over the manifest version', () => {
+        mockExpoConstants(EXPO_CONFIG, { nativeAppVersion: '1.9.158', nativeBuildVersion: '428' });
+        const resolve = loadResolve();
+        const identity = resolve();
+        // A stale manifest shouldn't misreport which build is actually running.
+        expect(identity.app.version).toBe('1.9.158');
+        expect(identity.app.buildNumber).toBe('428');
+    });
+    it('falls back to the manifest version when no native version is exposed', () => {
+        mockExpoConstants(EXPO_CONFIG);
+        const resolve = loadResolve();
+        const identity = resolve();
+        expect(identity.app.version).toBe('1.9.157');
+        expect(identity.app.buildNumber).toBe('427');
+    });
+    // Inside Yaver's container the ambient runtime IS Yaver. These are the
+    // cases where getting it wrong routes a fix task into yaver.io and edits
+    // the SDK instead of the app under test.
+    describe('inside the Yaver container (Hermes guest)', () => {
+        const YAVER_CONFIG = {
+            name: 'Yaver',
+            version: '1.99.306',
+            ios: { bundleIdentifier: 'io.yaver.mobile' },
+            android: { package: 'io.yaver.mobile' },
+        };
+        function mockContainer(yaverInfo) {
+            mockReactNative.NativeModules = { YaverInfo: { isYaver: true, ...yaverInfo } };
+            // The host's manifest — what expo-constants answers for a guest bundle.
+            mockExpoConstants(YAVER_CONFIG);
+        }
+        it("never reports the host's bundle id as the guest's", () => {
+            mockContainer({ inheritedGuestProjectName: 'talos / mobile' });
+            const resolve = loadResolve();
+            const identity = resolve();
+            // The agent routes on bundle id FIRST. Leaking io.yaver.mobile here
+            // would resolve to yaver.io and the project name would never be read.
+            expect(identity.project?.bundleId).toBeUndefined();
+            expect(identity.app.bundleId).toBeUndefined();
+            // Nor should the host's version masquerade as the guest's build.
+            expect(identity.app.version).toBeUndefined();
+        });
+        it('reports the guest project Yaver pinned', () => {
+            mockContainer({ inheritedGuestProjectName: 'talos / mobile' });
+            const resolve = loadResolve();
+            const identity = resolve();
+            expect(identity.appName).toBe('talos / mobile');
+            expect(identity.project?.projectName).toBe('talos / mobile');
+        });
+        it("lets the app's own declaration win over the pinned project", () => {
+            mockContainer({ inheritedGuestProjectName: 'something-else' });
+            const resolve = loadResolve();
+            // A bundle knows its own identity; nothing ambient should override it.
+            const identity = resolve({ projectName: 'Talos', bundleId: 'works.talos.mobile' });
+            expect(identity.appName).toBe('Talos');
+            expect(identity.project?.bundleId).toBe('works.talos.mobile');
+        });
+        it('reports nothing rather than something wrong when no project is pinned', () => {
+            mockContainer({});
+            const resolve = loadResolve();
+            // Better for the agent to reject/fall back than to confidently edit
+            // the wrong repo.
+            const identity = resolve();
+            expect(identity.project).toBeUndefined();
+            expect(identity.appName).toBeUndefined();
+            expect(identity.app).toEqual({});
+        });
+    });
+    it('lets an explicit declaration override the ambient identity', () => {
+        mockExpoConstants(EXPO_CONFIG);
+        const resolve = loadResolve();
+        const identity = resolve({ projectName: 'Override', bundleId: 'com.override.app' });
+        expect(identity.appName).toBe('Override');
+        expect(identity.project?.bundleId).toBe('com.override.app');
+    });
+    it('passes declared surfaces stacks and voice metadata through', () => {
+        mockExpoConstants(EXPO_CONFIG);
+        const resolve = loadResolve();
+        const identity = resolve({
+            projectName: 'Omni',
+            bundleId: 'io.example.omni',
+            surface: 'vision',
+            surfaces: ['mobile', 'web', 'watch', 'tv', 'car', 'vision'],
+            stack: 'react-native-expo',
+            stacks: ['react-native-expo', 'nextjs', 'yaver-xml'],
+            testSurfaces: ['rn-hermes', 'browser', 'visionos-simulator'],
+            feedbackSdk: 'yaver-feedback-react-native',
+            feedbackTransport: 'device-sdk',
+            voiceCapabilities: ['stt', 'tts', 'device-mic'],
+            sttProvider: 'deepgram',
+            ttsProvider: 'local',
+        });
+        expect(identity.project).toMatchObject({
+            surface: 'vision',
+            surfaces: ['mobile', 'web', 'watch', 'tv', 'car', 'vision'],
+            stack: 'react-native-expo',
+            stacks: ['react-native-expo', 'nextjs', 'yaver-xml'],
+            testSurfaces: ['rn-hermes', 'browser', 'visionos-simulator'],
+            feedbackSdk: 'yaver-feedback-react-native',
+            feedbackTransport: 'device-sdk',
+            voiceCapabilities: ['stt', 'tts', 'device-mic'],
+            sttProvider: 'deepgram',
+            ttsProvider: 'local',
+        });
+        expect(identity.project?.projectPath).toBeUndefined();
+    });
+    it('omits the project block when nothing identifies the app', () => {
+        // Bare RN with no expo-constants and no native modules. The report must
+        // still upload — the agent just resolves it by its own means.
+        mockExpoModule.default = {};
+        const resolve = loadResolve();
+        const identity = resolve();
+        expect(identity.project).toBeUndefined();
+        expect(identity.appName).toBeUndefined();
+        expect(identity.app).toEqual({});
+    });
+});

package/dist/__tests__/SDKToken.test.js

@@ -32,7 +32,7 @@ describe('SDK Token Auth', () => {
             const bundle = {
                 metadata: {
                     timestamp: '2026-03-25T00: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: [],