yaver-feedback-react-native 0.5.3 → 0.5.5

package/dist/P2PClient.js

@@ -0,0 +1,357 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.P2PClient = void 0;
+const react_native_1 = require("react-native");
+/**
+ * Lightweight P2P HTTP client for communicating with a Yaver agent.
+ *
+ * Reuses the same endpoint patterns as the main upload module but adds
+ * support for streaming feedback, listing builds, and triggering builds.
+ */
+class P2PClient {
+    constructor(baseUrl, authToken) {
+        this.baseUrl = baseUrl.replace(/\/$/, '');
+        this.authToken = authToken;
+    }
+    /** Update the base URL (e.g. after re-discovery). */
+    setBaseUrl(url) {
+        this.baseUrl = url.replace(/\/$/, '');
+    }
+    /** Update the auth token. */
+    setAuthToken(token) {
+        this.authToken = token;
+    }
+    /** Health check — returns true if the agent is reachable. */
+    async health() {
+        try {
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), 3000);
+            const response = await fetch(`${this.baseUrl}/health`, {
+                method: 'GET',
+                signal: controller.signal,
+            });
+            clearTimeout(timeoutId);
+            return response.ok;
+        }
+        catch {
+            return false;
+        }
+    }
+    /** Get agent info (hostname, version, platform). */
+    async info() {
+        const response = await this.request('GET', '/health');
+        const data = await response.json();
+        return {
+            hostname: data.hostname ?? data.name ?? 'Unknown',
+            version: data.version ?? 'unknown',
+            platform: data.platform ?? 'unknown',
+        };
+    }
+    /**
+     * Upload a feedback bundle via multipart POST.
+     * @returns The feedback report ID from the agent.
+     */
+    async uploadFeedback(bundle) {
+        const formData = new FormData();
+        formData.append('metadata', JSON.stringify(bundle.metadata));
+        for (let i = 0; i < bundle.screenshots.length; i++) {
+            const path = bundle.screenshots[i];
+            formData.append(`screenshot_${i}`, {
+                uri: react_native_1.Platform.OS === 'android' ? `file://${path}` : path,
+                type: 'image/png',
+                name: `screenshot_${i}.png`,
+            });
+        }
+        if (bundle.audio) {
+            formData.append('audio', {
+                uri: react_native_1.Platform.OS === 'android' ? `file://${bundle.audio}` : bundle.audio,
+                type: 'audio/m4a',
+                name: 'voice_note.m4a',
+            });
+        }
+        if (bundle.video) {
+            formData.append('video', {
+                uri: react_native_1.Platform.OS === 'android' ? `file://${bundle.video}` : bundle.video,
+                type: 'video/mp4',
+                name: 'screen_recording.mp4',
+            });
+        }
+        const response = await fetch(`${this.baseUrl}/feedback`, {
+            method: 'POST',
+            headers: {
+                Authorization: `Bearer ${this.authToken}`,
+            },
+            body: formData,
+        });
+        if (!response.ok) {
+            const text = await response.text().catch(() => '');
+            throw new Error(`[P2PClient] Upload failed (${response.status}): ${text}`);
+        }
+        const result = await response.json();
+        return result.id ?? result.reportId ?? 'unknown';
+    }
+    /**
+     * Stream feedback events to the agent in live mode.
+     * Sends each event as a JSON POST to `/feedback/stream`.
+     */
+    async streamFeedback(events) {
+        for await (const event of events) {
+            const response = await fetch(`${this.baseUrl}/feedback/stream`, {
+                method: 'POST',
+                headers: {
+                    Authorization: `Bearer ${this.authToken}`,
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify(event),
+            });
+            if (!response.ok) {
+                const text = await response.text().catch(() => '');
+                throw new Error(`[P2PClient] Stream event failed (${response.status}): ${text}`);
+            }
+        }
+    }
+    /** List available builds from the agent. */
+    async listBuilds() {
+        const response = await this.request('GET', '/builds');
+        const data = await response.json();
+        return data.builds ?? data ?? [];
+    }
+    /** Start a build for the given platform. */
+    async startBuild(platform) {
+        const response = await fetch(`${this.baseUrl}/builds`, {
+            method: 'POST',
+            headers: {
+                Authorization: `Bearer ${this.authToken}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({ platform }),
+        });
+        if (!response.ok) {
+            const text = await response.text().catch(() => '');
+            throw new Error(`[P2PClient] Start build failed (${response.status}): ${text}`);
+        }
+        return response.json();
+    }
+    /**
+     * Get voice capability info from the agent.
+     * voiceInputEnabled is always true — mobile can always record and send audio.
+     * s2sProvider/sttProvider indicate whether transcription is available.
+     */
+    async voiceStatus() {
+        const response = await this.request('GET', '/voice/status');
+        const data = await response.json();
+        return {
+            voiceInputEnabled: data.voiceInputEnabled ?? true,
+            s2sProvider: data.s2sProvider ?? undefined,
+            s2sReady: data.s2sReady ?? false,
+            sttProvider: data.sttProvider ?? undefined,
+            sttReady: data.sttReady ?? false,
+        };
+    }
+    /**
+     * Send voice audio to the agent for transcription.
+     * Works with any configured STT or S2S provider on the agent.
+     * If no provider is configured, audio is saved for manual review.
+     * @returns Transcribed text (or empty string if no provider available).
+     */
+    async transcribeVoice(audioUri) {
+        const formData = new FormData();
+        formData.append('audio', {
+            uri: react_native_1.Platform.OS === 'android' ? `file://${audioUri}` : audioUri,
+            type: 'audio/wav',
+            name: 'voice_input.wav',
+        });
+        const response = await fetch(`${this.baseUrl}/voice/transcribe`, {
+            method: 'POST',
+            headers: {
+                Authorization: `Bearer ${this.authToken}`,
+            },
+            body: formData,
+        });
+        if (!response.ok) {
+            const text = await response.text().catch(() => '');
+            throw new Error(`[P2PClient] Voice transcribe failed (${response.status}): ${text}`);
+        }
+        const result = await response.json();
+        return {
+            text: result.text ?? '',
+            provider: result.provider ?? 'none',
+            audioFile: result.audioFile,
+        };
+    }
+    /**
+     * Trigger a reload of the third-party app.
+     * In dev mode, this tells the dev server to hot-reload.
+     * In bundle mode, this rebuilds the native bundle and pushes it.
+     * The reload command is also broadcast to all connected SDK devices
+     * via the BlackBox command channel.
+     * @param mode - "dev" for hot reload, "bundle" for native bundle rebuild
+     */
+    async reloadApp(mode = 'dev') {
+        const response = await fetch(`${this.baseUrl}/dev/reload-app`, {
+            method: 'POST',
+            headers: {
+                Authorization: `Bearer ${this.authToken}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({ mode }),
+        });
+        if (!response.ok) {
+            const text = await response.text().catch(() => '');
+            throw new Error(`[P2PClient] Reload app failed (${response.status}): ${text}`);
+        }
+        return response.json();
+    }
+    /** Get the download URL for a build artifact. */
+    getArtifactUrl(buildId) {
+        return `${this.baseUrl}/builds/${buildId}/artifact`;
+    }
+    /**
+     * Start an autonomous test session.
+     * The agent reads the codebase for context, then navigates the app
+     * on the connected device/emulator, catches exceptions via BlackBox,
+     * writes fixes, and hot reloads — all without committing.
+     */
+    async startTestSession() {
+        const response = await fetch(`${this.baseUrl}/test-app/start`, {
+            method: 'POST',
+            headers: {
+                Authorization: `Bearer ${this.authToken}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({ source: 'feedback-sdk' }),
+        });
+        if (!response.ok) {
+            const text = await response.text().catch(() => '');
+            throw new Error(`[P2PClient] Start test session failed (${response.status}): ${text}`);
+        }
+        return response.json();
+    }
+    /** Stop a running test session. */
+    async stopTestSession() {
+        await fetch(`${this.baseUrl}/test-app/stop`, {
+            method: 'POST',
+            headers: { Authorization: `Bearer ${this.authToken}` },
+        });
+    }
+    /** Get the current test session status and list of fixes. */
+    async getTestSession() {
+        const response = await this.request('GET', '/test-app/status');
+        return response.json();
+    }
+    /**
+     * Rotate the SDK token. The old token stays valid for 5 minutes (grace period).
+     * After rotation, the client automatically uses the new token.
+     * @returns The new token and its expiry time.
+     */
+    async rotateToken() {
+        const response = await fetch(`${this.baseUrl}/sdk/token/rotate`, {
+            method: 'POST',
+            headers: {
+                Authorization: `Bearer ${this.authToken}`,
+                'Content-Type': 'application/json',
+            },
+        });
+        if (!response.ok) {
+            const text = await response.text().catch(() => '');
+            throw new Error(`[P2PClient] Token rotation failed (${response.status}): ${text}`);
+        }
+        const result = await response.json();
+        // Auto-update to new token
+        this.authToken = result.token;
+        return { token: result.token, expiresAt: result.expiresAt };
+    }
+    // ─── Feature flags (F1) ──────────────────────────────────────────
+    /**
+     * Evaluate every flag for a userId. Hits /flags/eval which uses
+     * SHA256 bucketing against rolloutPercent — stable per user per
+     * flag. Results are the dev's source of truth; the SDK caches
+     * for 30s in getFlagsCached().
+     */
+    async flagsEvaluate(userId = 'anonymous') {
+        const res = await fetch(`${this.baseUrl}/flags/eval?userId=${encodeURIComponent(userId)}`, { headers: { Authorization: `Bearer ${this.authToken}` } });
+        if (!res.ok)
+            return {};
+        const data = await res.json();
+        return data.flags ?? {};
+    }
+    /** Evaluate a single flag by key — shortcut when you only need one. */
+    async flagsEvaluateOne(key, userId = 'anonymous') {
+        const res = await fetch(`${this.baseUrl}/flags/eval?userId=${encodeURIComponent(userId)}&flag=${encodeURIComponent(key)}`, { headers: { Authorization: `Bearer ${this.authToken}` } });
+        if (!res.ok)
+            return undefined;
+        const data = await res.json();
+        return data.value;
+    }
+    // ─── Releases (R1) ───────────────────────────────────────────────
+    /**
+     * Ask what bundle this device should run. Returns the latest
+     * release in the channel plus a rollout gate. The mobile app
+     * uses this on cold start to decide whether to download a new
+     * bundle from /releases/bundle.
+     */
+    async releasesLatest(channel = 'production', deviceId) {
+        const params = new URLSearchParams({ channel });
+        if (deviceId)
+            params.set('device', deviceId);
+        const res = await fetch(`${this.baseUrl}/releases/latest?${params.toString()}`, {
+            headers: { Authorization: `Bearer ${this.authToken}` },
+        });
+        if (!res.ok)
+            return null;
+        return res.json();
+    }
+    /** Download a specific bundle as raw bytes. */
+    async releasesDownload(channel, semver) {
+        const params = new URLSearchParams({ channel, semver });
+        const res = await fetch(`${this.baseUrl}/releases/bundle?${params.toString()}`, {
+            headers: { Authorization: `Bearer ${this.authToken}` },
+        });
+        if (!res.ok)
+            return null;
+        return res.arrayBuffer();
+    }
+    // ─── Analytics ingest (A1 — direct POST path) ───────────────────
+    /**
+     * Fire-and-forget track event. Most callers should use
+     * `BlackBox.track()` which fans through the streaming channel;
+     * this method is the fallback for surfaces without a live SSE.
+     */
+    async analyticsIngest(name, props, opts) {
+        try {
+            const res = await fetch(`${this.baseUrl}/analytics/ingest`, {
+                method: 'POST',
+                headers: {
+                    Authorization: `Bearer ${this.authToken}`,
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({
+                    name,
+                    props,
+                    deviceId: opts?.deviceId,
+                    route: opts?.route,
+                    timestamp: opts?.timestamp ?? Date.now(),
+                }),
+            });
+            return res.ok;
+        }
+        catch {
+            return false;
+        }
+    }
+    /** Internal helper for authenticated GET/POST requests. */
+    async request(method, path) {
+        const response = await fetch(`${this.baseUrl}${path}`, {
+            method,
+            headers: {
+                Authorization: `Bearer ${this.authToken}`,
+            },
+        });
+        if (!response.ok) {
+            const text = await response.text().catch(() => '');
+            throw new Error(`[P2PClient] ${method} ${path} failed (${response.status}): ${text}`);
+        }
+        return response;
+    }
+}
+exports.P2PClient = P2PClient;

package/dist/ShakeDetector.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Detects device shake gestures.
+ *
+ * Two detection paths run in parallel so shake works in both Debug and
+ * Release / TestFlight builds:
+ *
+ *   1. React Native's built-in `shakeEvent` (iOS) / `ShakeEvent` (Android)
+ *      on `DeviceEventEmitter`. RN emits `shakeEvent` only in Debug mode
+ *      on iOS, which is why TestFlight builds never saw a shake prior to
+ *      SDK 0.5.1.
+ *   2. Accelerometer-based fallback via `expo-sensors` (optional peer
+ *      dep). When the host app has `expo-sensors` installed we subscribe
+ *      to the accelerometer and fire on a burst of above-threshold peaks.
+ *      This path works identically in Debug, Release, and TestFlight.
+ *
+ * Both paths share a 1-second debounce so a single shake never fires the
+ * callback twice.
+ */
+export declare class ShakeDetector {
+    private devMenuSub;
+    private accelSub;
+    private lastShakeTime;
+    private peakTimestamps;
+    start(onShake: () => void): void;
+    stop(): void;
+    private fire;
+    /**
+     * Dev-menu / platform-native event listener. On iOS this is the
+     * `shakeEvent` RN posts from RCTDevMenu (Debug only). On Android it is
+     * the `ShakeEvent` name a handful of third-party shake libraries emit.
+     */
+    private subscribeDevMenu;
+    /**
+     * Accelerometer-based detection. Uses `expo-sensors` when available —
+     * the host app's own dependency, not the SDK's, so apps that don't
+     * want the extra native surface get the Dev-menu path only.
+     */
+    private subscribeAccelerometer;
+}

package/dist/ShakeDetector.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ShakeDetector = void 0;
+const react_native_1 = require("react-native");
+// Detects that the surrounding runtime is Yaver's super-host bridge. The
+// YaverInfo native module is only registered inside Yaver's container
+// (see mobile/ios/Yaver/YaverInfo.{swift,m} and the Android equivalent),
+// so it is undefined in a standalone third-party app. When the SDK runs
+// inside Yaver we yield shake handling to Yaver's native
+// ShakeDetectingWindow — the user should only ever see the 2-button
+// "Reload / Back to Yaver" overlay, never a FeedbackModal popped from
+// inside the guest bundle.
+function isRunningInsideYaverHost() {
+    try {
+        return !!react_native_1.NativeModules?.YaverInfo;
+    }
+    catch {
+        return false;
+    }
+}
+const SHAKE_TIMEOUT_MS = 1000; // minimum time between shakes
+const ACCEL_THRESHOLD_G = 1.8; // peak g-force that qualifies as a shake event
+const ACCEL_MIN_HITS = 3; // peaks within the window before we fire
+const ACCEL_WINDOW_MS = 800; // rolling window
+const ACCEL_SAMPLE_INTERVAL_MS = 80; // ≈12Hz — cheap but catches shakes
+/**
+ * Detects device shake gestures.
+ *
+ * Two detection paths run in parallel so shake works in both Debug and
+ * Release / TestFlight builds:
+ *
+ *   1. React Native's built-in `shakeEvent` (iOS) / `ShakeEvent` (Android)
+ *      on `DeviceEventEmitter`. RN emits `shakeEvent` only in Debug mode
+ *      on iOS, which is why TestFlight builds never saw a shake prior to
+ *      SDK 0.5.1.
+ *   2. Accelerometer-based fallback via `expo-sensors` (optional peer
+ *      dep). When the host app has `expo-sensors` installed we subscribe
+ *      to the accelerometer and fire on a burst of above-threshold peaks.
+ *      This path works identically in Debug, Release, and TestFlight.
+ *
+ * Both paths share a 1-second debounce so a single shake never fires the
+ * callback twice.
+ */
+class ShakeDetector {
+    constructor() {
+        this.devMenuSub = null;
+        this.accelSub = null;
+        this.lastShakeTime = 0;
+        this.peakTimestamps = [];
+    }
+    start(onShake) {
+        this.stop();
+        // When the app is loaded inside Yaver's super-host (Hermes push),
+        // Yaver owns the shake gesture and shows its own "Reload / Back to
+        // Yaver" overlay. We must not also fire the guest-side callback,
+        // otherwise the user gets both UIs at once.
+        if (isRunningInsideYaverHost())
+            return;
+        this.subscribeDevMenu(onShake);
+        this.subscribeAccelerometer(onShake);
+    }
+    stop() {
+        if (this.devMenuSub) {
+            this.devMenuSub.remove();
+            this.devMenuSub = null;
+        }
+        if (this.accelSub) {
+            this.accelSub.remove();
+            this.accelSub = null;
+        }
+        this.peakTimestamps = [];
+    }
+    fire(onShake) {
+        const now = Date.now();
+        if (now - this.lastShakeTime <= SHAKE_TIMEOUT_MS)
+            return;
+        this.lastShakeTime = now;
+        this.peakTimestamps = [];
+        onShake();
+    }
+    /**
+     * Dev-menu / platform-native event listener. On iOS this is the
+     * `shakeEvent` RN posts from RCTDevMenu (Debug only). On Android it is
+     * the `ShakeEvent` name a handful of third-party shake libraries emit.
+     */
+    subscribeDevMenu(onShake) {
+        const eventName = react_native_1.Platform.OS === 'ios' ? 'shakeEvent' : 'ShakeEvent';
+        this.devMenuSub = react_native_1.DeviceEventEmitter.addListener(eventName, () => {
+            this.fire(onShake);
+        });
+    }
+    /**
+     * Accelerometer-based detection. Uses `expo-sensors` when available —
+     * the host app's own dependency, not the SDK's, so apps that don't
+     * want the extra native surface get the Dev-menu path only.
+     */
+    subscribeAccelerometer(onShake) {
+        let Accelerometer = null;
+        try {
+            // Optional peer dep — if it isn't installed, we simply skip this path.
+            Accelerometer = require('expo-sensors').Accelerometer;
+        }
+        catch {
+            return;
+        }
+        if (!Accelerometer)
+            return;
+        try {
+            Accelerometer.setUpdateInterval(ACCEL_SAMPLE_INTERVAL_MS);
+        }
+        catch {
+            // Some platforms reject zero-value intervals; fall through with defaults
+        }
+        this.accelSub = Accelerometer.addListener(({ x, y, z }) => {
+            // Magnitude of acceleration vector (in g). Subtract 1 so a stationary
+            // device reports ~0 rather than the 1g of gravity.
+            const mag = Math.sqrt(x * x + y * y + z * z);
+            if (mag - 1 < ACCEL_THRESHOLD_G - 1)
+                return;
+            const now = Date.now();
+            this.peakTimestamps.push(now);
+            // Drop peaks that fell out of the rolling window.
+            while (this.peakTimestamps.length > 0 &&
+                now - this.peakTimestamps[0] > ACCEL_WINDOW_MS) {
+                this.peakTimestamps.shift();
+            }
+            if (this.peakTimestamps.length >= ACCEL_MIN_HITS) {
+                this.fire(onShake);
+            }
+        });
+    }
+}
+exports.ShakeDetector = ShakeDetector;