yaver-feedback-react-native 0.5.2 → 0.5.4

package/dist/YaverUpdates.d.ts

@@ -0,0 +1,78 @@
+export interface YaverUpdatesConfig {
+    /** Release channel to track. Default: "production". */
+    channel?: string;
+    /** Stable user identifier for rollout bucketing. */
+    userId?: string;
+    /** Poll interval in ms. 0 disables the poll loop. Default: 5 min. */
+    interval?: number;
+    /** Automatically download new bundles. Default: true. */
+    autoDownload?: boolean;
+    /**
+     * Callback fired when a new bundle has been downloaded and
+     * persisted. The dev's app can show an "update available" UI
+     * and call `applyPendingUpdate()` to trigger the reload.
+     */
+    onUpdateReady?: (info: PendingUpdate) => void;
+}
+/** Describes a downloaded-but-not-yet-applied update. */
+export interface PendingUpdate {
+    channel: string;
+    semver: string;
+    md5: string;
+    size: number;
+    downloadedAt: number;
+    bundlePath: string;
+}
+interface LatestResponse {
+    ok: boolean;
+    channel: string;
+    semver?: string;
+    size?: number;
+    md5?: string;
+    hermesBcVersion?: number;
+    bundleUrl?: string;
+    rolloutPercent: number;
+    inRollout: boolean;
+    reason?: string;
+}
+export declare class YaverUpdates {
+    private static cfg;
+    private static pollTimer;
+    private static pending;
+    private static fs;
+    private static started;
+    /**
+     * Start the OTA poll loop. Safe to call before init() finishes
+     * — the call defers until a P2PClient is available.
+     */
+    static init(config?: YaverUpdatesConfig): void;
+    /** Stop the poll loop. */
+    static stop(): void;
+    /**
+     * One-shot poll. Returns the latest release metadata. If a new
+     * bundle is available AND autoDownload is true, also downloads
+     * and caches it. Resolves to null on network / auth failure.
+     */
+    static checkForUpdate(): Promise<LatestResponse | null>;
+    /**
+     * Returns the currently-pending bundle (downloaded but not
+     * applied). Null if no update is waiting.
+     */
+    static getPendingUpdate(): PendingUpdate | null;
+    /**
+     * Apply a pending update. In dev builds this calls
+     * DevSettings.reload(). In release builds without a native
+     * module it returns false — the bundle is persisted but the
+     * OS will only load it on the next cold start, or after the
+     * future YaverUpdates native module lands.
+     */
+    static applyPendingUpdate(): Promise<boolean>;
+    /**
+     * Discard the cached pending bundle. Next cold start goes
+     * back to whatever was previously loaded.
+     */
+    static rollback(): Promise<void>;
+    private static downloadAndCache;
+    private static emitUpdateReady;
+}
+export {};

package/dist/YaverUpdates.js

@@ -0,0 +1,272 @@
+"use strict";
+// YaverUpdates — self-hosted OTA client for React Native apps.
+//
+// End-user apps poll the yaver agent's /releases/latest endpoint
+// through the P2P relay, download the matching Hermes bundle via
+// /releases/bundle, and optionally trigger a JS reload. The
+// bundle is stored on disk for a subsequent cold start to pick
+// up (v1 — this file does NOT hot-swap the live runtime; a
+// follow-up native module Swift/Kotlin will wire into Yaver's
+// existing safeReloadBridge path for true in-process swaps).
+//
+// What v1 ships:
+//
+//   - `YaverUpdates.init({ channel, userId, auto })` — polls
+//     /releases/latest on boot + every interval, downloads new
+//     bundles when inRollout, persists them to a known path,
+//     emits a BlackBox `lifecycle` event "update_ready".
+//   - `YaverUpdates.checkForUpdate()` — one-shot poll + download.
+//   - `YaverUpdates.applyPendingUpdate()` — calls
+//     DevSettings.reload() in dev builds, a no-op in release
+//     until the native module lands.
+//   - `YaverUpdates.rollback()` — deletes the cached bundle so
+//     the next cold start ignores it.
+//
+// Storage path is stable across restarts and matches what the
+// future native module will read:
+//
+//   <DocumentDirectory>/yaver-updates/<channel>/bundle.hbc
+//   <DocumentDirectory>/yaver-updates/<channel>/metadata.json
+//
+// The SDK writes to a temp path first and renames on success so
+// a mid-download crash never leaves a half-written bundle in
+// place.
+//
+// SELF-HOSTING WIN: the dev's own agent serves the bundle
+// through the dev's own relay. No EAS Update subscription, no
+// CodePush dependency, no central vendor. The bundle never
+// touches any server the dev doesn't control.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.YaverUpdates = void 0;
+const react_native_1 = require("react-native");
+const BlackBox_1 = require("./BlackBox");
+const YaverFeedback_1 = require("./YaverFeedback");
+// We feature-detect react-native-fs instead of hard-requiring
+// it. Devs who don't have it installed still get
+// checkForUpdate() polling + the BlackBox event, just without
+// disk persistence.
+function loadFS() {
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        const fs = require('react-native-fs');
+        return fs;
+    }
+    catch {
+        return null;
+    }
+}
+class YaverUpdates {
+    /**
+     * Start the OTA poll loop. Safe to call before init() finishes
+     * — the call defers until a P2PClient is available.
+     */
+    static init(config) {
+        if (YaverUpdates.started) {
+            YaverUpdates.cfg = {
+                channel: config?.channel ?? YaverUpdates.cfg?.channel ?? 'production',
+                userId: config?.userId ?? YaverUpdates.cfg?.userId ?? 'anonymous',
+                interval: config?.interval ?? YaverUpdates.cfg?.interval ?? 5 * 60 * 1000,
+                autoDownload: config?.autoDownload ?? YaverUpdates.cfg?.autoDownload ?? true,
+                onUpdateReady: config?.onUpdateReady ?? YaverUpdates.cfg?.onUpdateReady ?? (() => { }),
+            };
+            return;
+        }
+        YaverUpdates.started = true;
+        YaverUpdates.fs = loadFS();
+        YaverUpdates.cfg = {
+            channel: config?.channel ?? 'production',
+            userId: config?.userId ?? 'anonymous',
+            interval: config?.interval ?? 5 * 60 * 1000,
+            autoDownload: config?.autoDownload ?? true,
+            onUpdateReady: config?.onUpdateReady ?? (() => { }),
+        };
+        // Kick off the first check immediately so devs see an
+        // update-available banner on the very next app cold start.
+        YaverUpdates.checkForUpdate().catch(() => { });
+        if (YaverUpdates.cfg.interval > 0) {
+            YaverUpdates.pollTimer = setInterval(() => YaverUpdates.checkForUpdate().catch(() => { }), YaverUpdates.cfg.interval);
+        }
+    }
+    /** Stop the poll loop. */
+    static stop() {
+        if (YaverUpdates.pollTimer) {
+            clearInterval(YaverUpdates.pollTimer);
+            YaverUpdates.pollTimer = null;
+        }
+    }
+    /**
+     * One-shot poll. Returns the latest release metadata. If a new
+     * bundle is available AND autoDownload is true, also downloads
+     * and caches it. Resolves to null on network / auth failure.
+     */
+    static async checkForUpdate() {
+        const cfg = YaverUpdates.cfg;
+        if (!cfg)
+            return null;
+        const client = YaverFeedback_1.YaverFeedback.getP2PClient();
+        if (!client)
+            return null;
+        const latest = await client.releasesLatest(cfg.channel, cfg.userId);
+        if (!latest || !latest.semver)
+            return latest;
+        if (!latest.inRollout)
+            return latest;
+        // Skip if we already have this bundle cached.
+        if (YaverUpdates.pending && YaverUpdates.pending.semver === latest.semver) {
+            return latest;
+        }
+        if (cfg.autoDownload) {
+            await YaverUpdates.downloadAndCache(client, latest);
+        }
+        return latest;
+    }
+    /**
+     * Returns the currently-pending bundle (downloaded but not
+     * applied). Null if no update is waiting.
+     */
+    static getPendingUpdate() {
+        return YaverUpdates.pending;
+    }
+    /**
+     * Apply a pending update. In dev builds this calls
+     * DevSettings.reload(). In release builds without a native
+     * module it returns false — the bundle is persisted but the
+     * OS will only load it on the next cold start, or after the
+     * future YaverUpdates native module lands.
+     */
+    static async applyPendingUpdate() {
+        if (!YaverUpdates.pending)
+            return false;
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-require-imports
+            const rn = require('react-native');
+            if (rn?.DevSettings?.reload) {
+                rn.DevSettings.reload();
+                return true;
+            }
+        }
+        catch {
+            // fall through
+        }
+        return false;
+    }
+    /**
+     * Discard the cached pending bundle. Next cold start goes
+     * back to whatever was previously loaded.
+     */
+    static async rollback() {
+        if (!YaverUpdates.pending || !YaverUpdates.fs) {
+            YaverUpdates.pending = null;
+            return;
+        }
+        try {
+            await YaverUpdates.fs.unlink?.(YaverUpdates.pending.bundlePath);
+        }
+        catch {
+            // swallow — the bundle may already be gone
+        }
+        YaverUpdates.pending = null;
+    }
+    // --- internals ---------------------------------------------------
+    static async downloadAndCache(client, latest) {
+        if (!latest.semver || !latest.md5 || !latest.size)
+            return;
+        const bytes = await client.releasesDownload(latest.channel, latest.semver);
+        if (!bytes)
+            return;
+        const info = {
+            channel: latest.channel,
+            semver: latest.semver,
+            md5: latest.md5,
+            size: latest.size,
+            downloadedAt: Date.now(),
+            bundlePath: '',
+        };
+        const fs = YaverUpdates.fs;
+        if (!fs || !fs.DocumentDirectoryPath || !fs.writeFile) {
+            // No FS — still expose the pending record in-memory so
+            // the dev's app can react to the BlackBox event.
+            YaverUpdates.pending = info;
+            YaverUpdates.emitUpdateReady(info);
+            return;
+        }
+        const dir = `${fs.DocumentDirectoryPath}/yaver-updates/${latest.channel}`;
+        try {
+            await fs.mkdir?.(dir);
+        }
+        catch {
+            // mkdir -p — directory may already exist
+        }
+        const bundlePath = `${dir}/bundle.hbc`;
+        const tmpPath = `${bundlePath}.tmp`;
+        // react-native-fs writeFile accepts base64 or utf8; Hermes
+        // bundles are binary so we encode the ArrayBuffer as base64.
+        const base64 = bufferToBase64(bytes);
+        await fs.writeFile(tmpPath, base64, 'base64');
+        try {
+            await fs.unlink?.(bundlePath);
+        }
+        catch {
+            // fine — no previous bundle
+        }
+        // We can't atomic-rename without a native bridge, so the
+        // tmpPath -> bundlePath swap is a copy + delete. For a dev
+        // runtime this is fine; the native shim will tighten it.
+        try {
+            const rename = fs.moveFile;
+            if (rename) {
+                await rename(tmpPath, bundlePath);
+            }
+            else {
+                // Best-effort fallback: write directly to bundlePath on
+                // the next attempt. Leaves a .tmp around, which the next
+                // run will overwrite.
+            }
+        }
+        catch {
+            // swallow
+        }
+        info.bundlePath = bundlePath;
+        YaverUpdates.pending = info;
+        YaverUpdates.emitUpdateReady(info);
+    }
+    static emitUpdateReady(info) {
+        BlackBox_1.BlackBox.lifecycle('yaver-updates: bundle downloaded', {
+            channel: info.channel,
+            semver: info.semver,
+            md5: info.md5,
+            size: info.size,
+            platform: react_native_1.Platform.OS,
+        });
+        const cb = YaverUpdates.cfg?.onUpdateReady;
+        if (cb) {
+            try {
+                cb(info);
+            }
+            catch {
+                // dev callback threw — don't let it stall the poll loop
+            }
+        }
+    }
+}
+exports.YaverUpdates = YaverUpdates;
+YaverUpdates.cfg = null;
+YaverUpdates.pollTimer = null;
+YaverUpdates.pending = null;
+YaverUpdates.fs = null;
+YaverUpdates.started = false;
+// Small ArrayBuffer -> base64 helper with no external deps so
+// the SDK package doesn't balloon. Safe for small bundles
+// (~10MB worst case) and runs on every RN target without
+// polyfills.
+function bufferToBase64(buf) {
+    const bytes = new Uint8Array(buf);
+    let binary = '';
+    const chunk = 0x8000;
+    for (let i = 0; i < bytes.length; i += chunk) {
+        binary += String.fromCharCode(...bytes.subarray(i, i + chunk));
+    }
+    // btoa exists in both React Native's Hermes and Node for tests.
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return globalThis.btoa(binary);
+}

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

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

package/dist/__tests__/Discovery.test.js

@@ -0,0 +1,164 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const Discovery_1 = require("../Discovery");
+// Mock fetch globally
+const mockFetch = jest.fn();
+global.fetch = mockFetch;
+// Mock AsyncStorage. Discovery.ts requires it via `.default`, so the mock
+// must expose its API on a `default` property too.
+const mockStorage = {};
+const mockAsyncStorage = {
+    getItem: jest.fn((key) => Promise.resolve(mockStorage[key] || null)),
+    setItem: jest.fn((key, value) => {
+        mockStorage[key] = value;
+        return Promise.resolve();
+    }),
+    removeItem: jest.fn((key) => {
+        delete mockStorage[key];
+        return Promise.resolve();
+    }),
+};
+jest.mock('@react-native-async-storage/async-storage', () => ({
+    __esModule: true,
+    default: mockAsyncStorage,
+    ...mockAsyncStorage,
+}));
+// Mock AbortController
+class MockAbortController {
+    constructor() {
+        this.signal = {};
+        this.abort = jest.fn();
+    }
+}
+global.AbortController = MockAbortController;
+beforeEach(() => {
+    jest.clearAllMocks();
+    mockFetch.mockReset();
+    // Clear mock storage
+    Object.keys(mockStorage).forEach((key) => delete mockStorage[key]);
+});
+describe('YaverDiscovery', () => {
+    describe('probe()', () => {
+        it('returns null for unreachable URLs', async () => {
+            mockFetch.mockRejectedValue(new Error('Network error'));
+            const result = await Discovery_1.YaverDiscovery.probe('http://192.168.1.99:18080');
+            expect(result).toBeNull();
+        });
+        it('returns null for non-ok responses', async () => {
+            mockFetch.mockResolvedValue({
+                ok: false,
+                status: 500,
+            });
+            const result = await Discovery_1.YaverDiscovery.probe('http://192.168.1.1:18080');
+            expect(result).toBeNull();
+        });
+        it('returns DiscoveryResult for a reachable agent', async () => {
+            mockFetch.mockResolvedValue({
+                ok: true,
+                json: () => Promise.resolve({ hostname: 'MacBook-Air', version: '1.44.0' }),
+            });
+            const result = await Discovery_1.YaverDiscovery.probe('http://192.168.1.10:18080');
+            expect(result).not.toBeNull();
+            expect(result.url).toBe('http://192.168.1.10:18080');
+            expect(result.hostname).toBe('MacBook-Air');
+            expect(result.version).toBe('1.44.0');
+            expect(typeof result.latency).toBe('number');
+        });
+        it('strips trailing slash from URL', async () => {
+            mockFetch.mockResolvedValue({
+                ok: true,
+                json: () => Promise.resolve({ hostname: 'test', version: '1.0' }),
+            });
+            const result = await Discovery_1.YaverDiscovery.probe('http://192.168.1.10:18080/');
+            expect(result.url).toBe('http://192.168.1.10:18080');
+        });
+        it('handles health endpoint returning non-JSON gracefully', async () => {
+            mockFetch.mockResolvedValue({
+                ok: true,
+                json: () => Promise.reject(new Error('not JSON')),
+            });
+            const result = await Discovery_1.YaverDiscovery.probe('http://192.168.1.10:18080');
+            expect(result).not.toBeNull();
+            expect(result.hostname).toBe('Unknown');
+            expect(result.version).toBe('unknown');
+        });
+    });
+    describe('getStored()', () => {
+        it('returns null when no stored connection', async () => {
+            const result = await Discovery_1.YaverDiscovery.getStored();
+            expect(result).toBeNull();
+        });
+        it('returns stored connection when available', async () => {
+            const AsyncStorage = require('@react-native-async-storage/async-storage');
+            mockStorage['yaver_feedback_agent'] = JSON.stringify({
+                url: 'http://192.168.1.10:18080',
+                hostname: 'MacBook',
+            });
+            const result = await Discovery_1.YaverDiscovery.getStored();
+            expect(result).not.toBeNull();
+            expect(result.url).toBe('http://192.168.1.10:18080');
+            expect(result.hostname).toBe('MacBook');
+        });
+        it('returns null for invalid stored JSON', async () => {
+            mockStorage['yaver_feedback_agent'] = 'not-json';
+            const result = await Discovery_1.YaverDiscovery.getStored();
+            expect(result).toBeNull();
+        });
+        it('returns null for stored data without url field', async () => {
+            mockStorage['yaver_feedback_agent'] = JSON.stringify({ hostname: 'test' });
+            const result = await Discovery_1.YaverDiscovery.getStored();
+            expect(result).toBeNull();
+        });
+    });
+    describe('store() and getStored() round-trip', () => {
+        it('stores and retrieves a DiscoveryResult', async () => {
+            const discovery = {
+                url: 'http://10.0.0.50:18080',
+                hostname: 'DevMachine',
+                version: '1.44.0',
+                latency: 5,
+            };
+            await Discovery_1.YaverDiscovery.store(discovery);
+            const stored = await Discovery_1.YaverDiscovery.getStored();
+            expect(stored).not.toBeNull();
+            expect(stored.url).toBe('http://10.0.0.50:18080');
+            expect(stored.hostname).toBe('DevMachine');
+        });
+    });
+    describe('clear()', () => {
+        it('removes stored connection', async () => {
+            const discovery = {
+                url: 'http://10.0.0.1:18080',
+                hostname: 'Test',
+                version: '1.0',
+                latency: 3,
+            };
+            await Discovery_1.YaverDiscovery.store(discovery);
+            const beforeClear = await Discovery_1.YaverDiscovery.getStored();
+            expect(beforeClear).not.toBeNull();
+            await Discovery_1.YaverDiscovery.clear();
+            const afterClear = await Discovery_1.YaverDiscovery.getStored();
+            expect(afterClear).toBeNull();
+        });
+    });
+    describe('connect()', () => {
+        it('probes and stores on success', async () => {
+            mockFetch.mockResolvedValue({
+                ok: true,
+                json: () => Promise.resolve({ hostname: 'Agent', version: '2.0' }),
+            });
+            const result = await Discovery_1.YaverDiscovery.connect('http://192.168.1.5:18080');
+            expect(result).not.toBeNull();
+            expect(result.hostname).toBe('Agent');
+            // Should be stored
+            const stored = await Discovery_1.YaverDiscovery.getStored();
+            expect(stored).not.toBeNull();
+            expect(stored.url).toBe('http://192.168.1.5:18080');
+        });
+        it('returns null and does not store on failure', async () => {
+            mockFetch.mockRejectedValue(new Error('unreachable'));
+            const result = await Discovery_1.YaverDiscovery.connect('http://192.168.1.99:18080');
+            expect(result).toBeNull();
+        });
+    });
+});

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

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

package/dist/__tests__/P2PClient.test.js

@@ -0,0 +1,169 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const P2PClient_1 = require("../P2PClient");
+// Mock react-native Platform
+jest.mock('react-native', () => ({
+    Platform: { OS: 'ios' },
+}));
+// Mock fetch globally
+const mockFetch = jest.fn();
+global.fetch = mockFetch;
+// Mock AbortController
+class MockAbortController {
+    constructor() {
+        this.signal = {};
+        this.abort = jest.fn();
+    }
+}
+global.AbortController = MockAbortController;
+beforeEach(() => {
+    jest.clearAllMocks();
+    mockFetch.mockReset();
+});
+describe('P2PClient', () => {
+    describe('constructor', () => {
+        it('sets baseUrl and authToken', () => {
+            const client = new P2PClient_1.P2PClient('http://192.168.1.10:18080', 'my-token');
+            // Verify via getArtifactUrl which uses baseUrl
+            expect(client.getArtifactUrl('build-123')).toBe('http://192.168.1.10:18080/builds/build-123/artifact');
+        });
+        it('strips trailing slash from baseUrl', () => {
+            const client = new P2PClient_1.P2PClient('http://192.168.1.10:18080/', 'tok');
+            expect(client.getArtifactUrl('b1')).toBe('http://192.168.1.10:18080/builds/b1/artifact');
+        });
+    });
+    describe('health()', () => {
+        it('returns false for unreachable agent', async () => {
+            mockFetch.mockRejectedValue(new Error('Network error'));
+            const client = new P2PClient_1.P2PClient('http://192.168.1.99:18080', 'tok');
+            const result = await client.health();
+            expect(result).toBe(false);
+        });
+        it('returns true when agent is reachable', async () => {
+            mockFetch.mockResolvedValue({ ok: true });
+            const client = new P2PClient_1.P2PClient('http://192.168.1.10:18080', 'tok');
+            const result = await client.health();
+            expect(result).toBe(true);
+        });
+        it('returns false for non-ok response', async () => {
+            mockFetch.mockResolvedValue({ ok: false, status: 503 });
+            const client = new P2PClient_1.P2PClient('http://192.168.1.10:18080', 'tok');
+            const result = await client.health();
+            expect(result).toBe(false);
+        });
+        it('calls /health endpoint', async () => {
+            mockFetch.mockResolvedValue({ ok: true });
+            const client = new P2PClient_1.P2PClient('http://10.0.0.1:18080', 'tok');
+            await client.health();
+            expect(mockFetch).toHaveBeenCalledWith('http://10.0.0.1:18080/health', expect.objectContaining({ method: 'GET' }));
+        });
+    });
+    describe('getArtifactUrl()', () => {
+        it('constructs correct URL for a build ID', () => {
+            const client = new P2PClient_1.P2PClient('http://192.168.1.10:18080', 'tok');
+            expect(client.getArtifactUrl('abc-123')).toBe('http://192.168.1.10:18080/builds/abc-123/artifact');
+        });
+        it('works with different base URLs', () => {
+            const client = new P2PClient_1.P2PClient('http://10.0.0.50:9090', 'tok');
+            expect(client.getArtifactUrl('xyz')).toBe('http://10.0.0.50:9090/builds/xyz/artifact');
+        });
+    });
+    describe('setBaseUrl()', () => {
+        it('updates the base URL used by subsequent calls', () => {
+            const client = new P2PClient_1.P2PClient('http://old-host:18080', 'tok');
+            client.setBaseUrl('http://new-host:18080');
+            expect(client.getArtifactUrl('b1')).toBe('http://new-host:18080/builds/b1/artifact');
+        });
+        it('strips trailing slash from new URL', () => {
+            const client = new P2PClient_1.P2PClient('http://old:18080', 'tok');
+            client.setBaseUrl('http://new:18080/');
+            expect(client.getArtifactUrl('b1')).toBe('http://new:18080/builds/b1/artifact');
+        });
+    });
+    describe('info()', () => {
+        it('returns agent info on success', async () => {
+            mockFetch.mockResolvedValue({
+                ok: true,
+                json: () => Promise.resolve({ hostname: 'MacBook', version: '1.44.0', platform: 'darwin' }),
+                text: () => Promise.resolve(''),
+            });
+            const client = new P2PClient_1.P2PClient('http://localhost:18080', 'tok');
+            const info = await client.info();
+            expect(info.hostname).toBe('MacBook');
+            expect(info.version).toBe('1.44.0');
+            expect(info.platform).toBe('darwin');
+        });
+        it('sends Authorization header', async () => {
+            mockFetch.mockResolvedValue({
+                ok: true,
+                json: () => Promise.resolve({ hostname: 'test' }),
+                text: () => Promise.resolve(''),
+            });
+            const client = new P2PClient_1.P2PClient('http://localhost:18080', 'my-secret-token');
+            await client.info();
+            expect(mockFetch).toHaveBeenCalledWith('http://localhost:18080/health', expect.objectContaining({
+                headers: expect.objectContaining({
+                    Authorization: 'Bearer my-secret-token',
+                }),
+            }));
+        });
+    });
+    describe('uploadFeedback()', () => {
+        it('sends a POST request to /feedback', async () => {
+            mockFetch.mockResolvedValue({
+                ok: true,
+                json: () => Promise.resolve({ id: 'report-456' }),
+                text: () => Promise.resolve(''),
+            });
+            const client = new P2PClient_1.P2PClient('http://localhost:18080', 'tok');
+            const bundle = {
+                metadata: {
+                    timestamp: '2026-03-24T00:00:00Z',
+                    device: {
+                        platform: 'ios',
+                        osVersion: '18.0',
+                        model: 'iPhone 16',
+                        screenWidth: 393,
+                        screenHeight: 852,
+                    },
+                    app: { bundleId: 'com.test', version: '1.0' },
+                    userNote: 'Button is broken',
+                },
+                screenshots: [],
+            };
+            const reportId = await client.uploadFeedback(bundle);
+            expect(reportId).toBe('report-456');
+            expect(mockFetch).toHaveBeenCalledWith('http://localhost:18080/feedback', expect.objectContaining({ method: 'POST' }));
+        });
+        it('throws on non-ok response', async () => {
+            mockFetch.mockResolvedValue({
+                ok: false,
+                status: 500,
+                text: () => Promise.resolve('Internal Server Error'),
+            });
+            const client = new P2PClient_1.P2PClient('http://localhost:18080', 'tok');
+            const bundle = {
+                metadata: {
+                    timestamp: '2026-03-24T00:00:00Z',
+                    device: { platform: 'ios', osVersion: '18', model: 'iPhone', screenWidth: 393, screenHeight: 852 },
+                    app: {},
+                },
+                screenshots: [],
+            };
+            await expect(client.uploadFeedback(bundle)).rejects.toThrow('Upload failed');
+        });
+    });
+    describe('listBuilds()', () => {
+        it('returns builds array on success', async () => {
+            const builds = [{ id: '1', platform: 'ios', status: 'complete' }];
+            mockFetch.mockResolvedValue({
+                ok: true,
+                json: () => Promise.resolve({ builds }),
+                text: () => Promise.resolve(''),
+            });
+            const client = new P2PClient_1.P2PClient('http://localhost:18080', 'tok');
+            const result = await client.listBuilds();
+            expect(result).toEqual(builds);
+        });
+    });
+});