yaver-feedback-react-native 0.8.13 → 0.9.2

package/dist/types.d.ts

@@ -1,3 +1,4 @@
+import type { BlackBoxConfig } from './BlackBox';
 /**
  * Remote browser-style sign-in session for a coding-agent CLI on the
  * connected yaver host. Mirrors runnerBrowserAuthSession on the agent
@@ -19,6 +20,53 @@ export interface RunnerBrowserAuthSession {
     updatedAt: number;
     completedAt?: number;
 }
+export interface RunnerAuthStatusRow {
+    id: string;
+    name: string;
+    installed: boolean;
+    ready: boolean;
+    authConfigured: boolean;
+    authSource?: string;
+    warning?: string;
+    error?: string;
+    path?: string;
+    detail?: string;
+    version?: string;
+}
+export interface OpenCodeProviderSummary {
+    id: string;
+    name?: string;
+    hasApiKey?: boolean;
+    baseUrl?: string;
+    models?: Array<{
+        id: string;
+        name?: string;
+        provider?: string;
+    }>;
+}
+export interface OpenCodeAgentSummary {
+    name: string;
+    model?: string;
+    description?: string;
+    isBuiltin?: boolean;
+}
+export interface OpenCodeConfigSummary {
+    path: string;
+    exists: boolean;
+    defaultAgent?: string;
+    model?: string;
+    smallModel?: string;
+    buildModel?: string;
+    planModel?: string;
+    providers?: OpenCodeProviderSummary[];
+    models?: Array<{
+        id: string;
+        name?: string;
+        provider?: string;
+    }>;
+    agents?: OpenCodeAgentSummary[];
+    diagnostics?: string[];
+}
 export interface IncidentEvent {
     id: string;
     timestamp: number;
@@ -74,9 +122,32 @@ export interface CapabilitySnapshot {
     };
     targets: Record<string, CapabilityTargetReadiness>;
 }
+/**
+ * Opt-in config for the overlay's "App Store screenshots" action and the
+ * `capture_store_shots` remote command. When set, the SDK can walk the
+ * app's routes on-device, screenshot each, and upload them to the agent
+ * (which runs the App Store Connect backend).
+ */
+export interface StoreShotsConfig {
+    /** Ordered routes to visit + screenshot (e.g. ['/(tabs)/home', ...]). */
+    routes: string[];
+    /** Navigation handle: a react-navigation ref or expo-router `router`. */
+    navigationRef?: any;
+    /** Also set metadata + attempt submit-for-review after upload. */
+    submit?: boolean;
+    /** Optional per-route screenshot names (defaults to NN_<route>). */
+    screens?: string[];
+}
 export interface FeedbackConfig {
     /** URL of the Yaver agent (e.g. "http://192.168.1.10:18080"). If omitted, auto-discovery is used. */
     agentUrl?: string;
+    /**
+     * Enables the overlay's "App Store screenshots" action + the
+     * `capture_store_shots` remote command. The host supplies the route
+     * list (and a navigation ref) once; the SDK captures the real running
+     * app — no simulator needed.
+     */
+    storeShots?: StoreShotsConfig;
     /**
      * Auth token for the Yaver agent. Optional in 0.5+: if omitted, the SDK
      * will hydrate one from AsyncStorage or show its in-app login screen
@@ -116,6 +187,39 @@ export interface FeedbackConfig {
      * If omitted with convexUrl, connects to the first online device.
      */
     preferredDeviceId?: string;
+    /**
+     * Identity of the app this SDK instance reports for. Both fields are
+     * resolved automatically from expo-constants / native modules when
+     * omitted, so most apps never set them.
+     *
+     * Set them when the ambient answer would be wrong — above all when the
+     * app's JS is pushed into Yaver's container as a Hermes guest. There the
+     * runtime IS Yaver: `expo-constants` and `SettingsManager` describe the
+     * host (`Yaver` / `io.yaver.mobile`), not the guest, so auto-resolution
+     * would file every report against Yaver's own repo and the fix task would
+     * edit the SDK instead of the app. Declaring identity here is the only
+     * answer that holds in both a standalone build and a guest bundle.
+     *
+     * `bundleId` is the key that actually routes: the agent matches it against
+     * each project's pbxproj / build.gradle / app.json. `projectName` is a
+     * fallback for platforms with no bundle id.
+     */
+    projectName?: string;
+    bundleId?: string;
+    /** Primary Yaver product surface for this app/package. */
+    surface?: YaverSurface;
+    /** All product surfaces this app/package owns. */
+    surfaces?: YaverSurface[];
+    /** Canonical development stack labels, e.g. react-native-expo, yaver-xml. */
+    stack?: string;
+    stacks?: string[];
+    /** Yaver preview/runtime targets that can exercise this app. */
+    testSurfaces?: string[];
+    feedbackSdk?: string;
+    feedbackTransport?: string;
+    voiceCapabilities?: string[];
+    sttProvider?: string;
+    ttsProvider?: string;
     /** How feedback collection is triggered */
     trigger?: 'shake' | 'floating-button' | 'manual';
     /**
@@ -156,6 +260,22 @@ export interface FeedbackConfig {
      * Calling `BlackBox.start()` manually is still safe — it's idempotent.
      */
     autoStartBlackBox?: boolean;
+    /**
+     * Config handed to BlackBox when the SDK auto-starts it.
+     *
+     * Without this there was no way to configure the flight recorder at all.
+     * The obvious move — and the one the README's own snippet makes — is:
+     *
+     *     YaverFeedback.init({ trigger: 'shake' });
+     *     BlackBox.start({ appName: 'my-app' });
+     *
+     * but that start() early-returns, because a zero-config init has no
+     * agentUrl yet (discovery resolves it asynchronously). The auto-start then
+     * fires ~500ms later once the agent and token exist and calls `start()`
+     * with NO arguments — so the host's config is silently dropped and appName
+     * is ''. Pass it here instead and the auto-start will honour it.
+     */
+    blackBox?: BlackBoxConfig;
     /**
      * Small tap-to-open icon that floats above the app so the user
      * doesn't have to shake every time they want to open feedback.
@@ -244,6 +364,26 @@ export interface FeedbackConfig {
      * Bugsnag, or any other error tracking tool.
      */
     maxCapturedErrors?: number;
+    /**
+     * Crash-aware reporting/fixing. Defaults to disabled.
+     *
+     * - enabled: records fatal errors into the SDK error buffer and enables
+     *   explicit `YaverFeedback.reportCrash(error)`.
+     * - installGlobalHandler: opt-in only. Wraps React Native's global ErrorUtils
+     *   handler without suppressing the existing handler. Leave false when Sentry,
+     *   Crashlytics, Bugsnag, or another crash tool owns the global handler.
+     * - autoFix: after uploading a crash report, ask the connected Yaver agent to
+     *   create a fix task. The normal BlackBox command stream can then deliver a
+     *   reload/reload_bundle command after the agent rebuilds.
+     * - captureScreenshot: attach a best-effort screenshot to the crash report.
+     */
+    crashReporting?: {
+        enabled?: boolean;
+        installGlobalHandler?: boolean;
+        autoFix?: boolean;
+        captureScreenshot?: boolean;
+        metadata?: Record<string, unknown>;
+    };
     /**
      * Which platforms the Build button targets.
      * - 'ios' — build iOS only
@@ -356,9 +496,36 @@ export interface CapturedError {
 }
 export interface FeedbackMetadata {
     timestamp: string;
-    device: DeviceInfo;
+    /**
+     * Wire key is `deviceInfo`, matching the Flutter + web SDKs and the
+     * agent's `FeedbackReport.DeviceInfo` (`json:"deviceInfo"`). This was
+     * `device` until 0.9.2 — a key the agent never read, so the whole block
+     * (platform, model, and the app name the fix router needs) was silently
+     * dropped on every React Native report. The agent still accepts the old
+     * key so builds already in the field keep working.
+     */
+    deviceInfo: DeviceInfo;
     app: AppInfo;
+    /**
+     * Which of the host's projects this report is about. The agent resolves
+     * a feedback→fix task's working directory from this; without it the task
+     * falls back to whatever directory the agent happens to be sitting in.
+     * Populated automatically by `resolveReportIdentity()`.
+     */
+    project?: FeedbackProjectRef;
     userNote?: string;
+    reportKind?: 'feedback' | 'auto-report' | 'crash';
+    crash?: {
+        message: string;
+        isFatal: boolean;
+        source: 'manual' | 'global-handler';
+        autoFixRequested?: boolean;
+    };
+    twin?: {
+        sessionId?: string;
+        surface?: string;
+        artifactDir?: string;
+    };
 }
 export interface DeviceInfo {
     platform: string;
@@ -366,12 +533,49 @@ export interface DeviceInfo {
     model: string;
     screenWidth: number;
     screenHeight: number;
+    /** Host app name. First key the agent's fix router checks. */
+    appName?: string;
 }
 export interface AppInfo {
     bundleId?: string;
     version?: string;
     buildNumber?: string;
 }
+/**
+ * Identifies the host project a report belongs to. Mirrors the web SDK's
+ * `FeedbackProjectRef` and the agent's `FeedbackProject`.
+ */
+export interface FeedbackProjectRef {
+    appName?: string;
+    projectName?: string;
+    /**
+     * Bundle identifier / applicationId. The only unambiguous key: an app's
+     * display name ("Talos") does not match the agent's registry name for it
+     * ("talos / mobile"), and one repo can hold several mobile projects that
+     * all share a name prefix. The agent matches this against the project's
+     * pbxproj, build.gradle, and app.json.
+     */
+    bundleId?: string;
+    /**
+     * Deliberately never set by this SDK. The agent ignores client-supplied
+     * paths for feedback reports (an untrusted guest could otherwise point the
+     * fix task's CWD at ~/.ssh) and resolves the path server-side. Present only
+     * so the type matches the wire format the agent parses.
+     */
+    projectPath?: string;
+    surface?: YaverSurface;
+    surfaces?: YaverSurface[];
+    stack?: string;
+    stacks?: string[];
+    testSurfaces?: string[];
+    feedbackSdk?: string;
+    feedbackTransport?: string;
+    voiceCapabilities?: string[];
+    sttProvider?: string;
+    ttsProvider?: string;
+    releaseChannel?: 'production' | 'candidate' | 'development';
+}
+export type YaverSurface = 'web' | 'mobile' | 'backend' | 'watch' | 'tv' | 'car' | 'vision' | 'desktop' | 'cli';
 export interface TimelineEvent {
     type: 'screenshot' | 'audio' | 'video';
     path: string;
@@ -438,12 +642,20 @@ export interface TestSession {
 export interface VoiceCapability {
     /** Always true — mobile can always record and send audio. */
     voiceInputEnabled: boolean;
-    /** Speech-to-speech provider (e.g. "personaplex", "openai"), or null. */
+    /** Speech-to-speech provider (legacy), or null. */
     s2sProvider?: string;
     /** Whether the S2S provider is ready for real-time sessions. */
     s2sReady?: boolean;
-    /** Speech-to-text provider for transcription (e.g. "whisper", "openai"). */
+    /** Speech-to-text provider for transcription, e.g. "deepgram" for Deepgram Flux. */
     sttProvider?: string;
     /** Whether STT is ready (auto-transcription of voice input). */
     sttReady?: boolean;
+    /** Text-to-speech provider for readback, e.g. "cartesia". */
+    ttsProvider?: string;
+    /** Whether TTS readback is ready. */
+    ttsReady?: boolean;
+    /** Whether the agent-side hands-free task loop is enabled. */
+    enabled?: boolean;
+    /** Default project slug used by the agent voice loop. */
+    defaultProject?: string;
 }

package/dist/voice.d.ts

@@ -0,0 +1,61 @@
+export interface SDKVoiceStartOpts {
+    /** WS URL for the agent voice stream — P2PClient.voiceStreamUrl(). */
+    wsUrl: string;
+    /** Auth headers — P2PClient.voiceAuthHeaders(). */
+    headers: Record<string, string>;
+    project?: string;
+    model?: string;
+    runner?: string;
+    /** Surface hint for the agent's prompt wrapper. */
+    surface?: string;
+    /** Max chars for the spoken readback (Cartesia default ~280). */
+    ttsBudget?: number;
+    /** Per-session STT engine. "" = agent default. "local" = free
+     *  whisper.cpp on the host; "deepgram" = Flux nova-3 streaming. */
+    sttProvider?: string;
+    /** Per-session TTS engine. "" = agent default. "local"/"device" =
+     *  client synthesizes from the result text; cloud engines stream PCM. */
+    ttsProvider?: string;
+}
+export interface SDKVoiceCallbacks {
+    /** Active engines, echoed by the agent right after start — lets the UI
+     *  show "Local" vs "Flux". */
+    onProviders?: (stt: string, tts: string) => void;
+    onTranscriptPartial?: (text: string) => void;
+    onTranscriptFinal?: (text: string) => void;
+    onTaskCreated?: (taskId: string) => void;
+    onTaskResult?: (taskId: string, text: string, status: string) => void;
+    onTTSReady?: (pcm: Uint8Array, sampleRate: number) => void;
+    onError?: (msg: string) => void;
+    onDone?: () => void;
+}
+/** True when the deps the voice stream needs (expo-file-system + buffer)
+ *  are installed. The feedback UI hides the mic button otherwise. */
+export declare function isVoiceStreamSupported(): boolean;
+export declare class SDKVoiceSession {
+    private ws;
+    private callbacks;
+    private ttsChunks;
+    private ttsTotalBytes;
+    private ttsSampleRate;
+    private closed;
+    constructor(callbacks: SDKVoiceCallbacks);
+    /** Open the WS and send the start frame. Resolves once open. */
+    start(opts: SDKVoiceStartOpts): Promise<void>;
+    /** Stream a recorded WAV/PCM file as binary frames. Records produced by
+     *  recordPcmWav() are LPCM 16-bit/16kHz mono with a 44-byte RIFF header
+     *  we strip here — the exact shape the backend → STT expects. */
+    streamAudioFile(uri: string, opts?: {
+        skipWavHeader?: boolean;
+        chunkBytes?: number;
+    }): Promise<void>;
+    /** Done speaking — flush STT and create the agent task. */
+    finalize(): void;
+    close(): void;
+    private handleMessage;
+}
+/** Wrap raw PCM (signed 16-bit LE) in a minimal WAV container for
+ *  expo-av playback. 44-byte header + samples. */
+export declare function wrapPCMAsWAV(pcm: Uint8Array, sampleRate: number, channels?: number): Uint8Array;
+/** Write a PCM buffer to a temp WAV file; returns its file:// URI. */
+export declare function pcmToTempWavURI(pcm: Uint8Array, sampleRate: number): Promise<string>;

package/dist/voice.js

@@ -0,0 +1,246 @@
+"use strict";
+// Voice vibe-coding for the feedback SDK — speak a change, the agent
+// acts (full MCP), and reads back a spoken headline. Ported from the
+// Yaver mobile app's AgentVoiceSession (mobile/src/lib/agentVoice.ts) but
+// decoupled from the app: connection details (WS URL + auth headers) come
+// from the SDK's P2PClient, so it works both inside the Yaver container
+// (inherited auth) and standalone in a third-party app.
+//
+// Local vs remote STT/TTS is decided entirely agent-side (free local
+// whisper.cpp by default, Deepgram/OpenAI/etc when keys are configured),
+// so nothing model-related is bundled here — the SDK just streams mic
+// audio and renders the transcript + TTS the agent sends back.
+//
+// expo-file-system + buffer are loaded lazily so a bare-RN app that
+// hasn't installed them can still use the rest of the SDK; the voice
+// button hides itself via isVoiceStreamSupported() when they're absent.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SDKVoiceSession = void 0;
+exports.isVoiceStreamSupported = isVoiceStreamSupported;
+exports.wrapPCMAsWAV = wrapPCMAsWAV;
+exports.pcmToTempWavURI = pcmToTempWavURI;
+function loadBuffer() {
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    return require('buffer').Buffer;
+}
+function loadFS() {
+    // expo-file-system v16+ moved the classic API under /legacy; fall back
+    // to the root export for older installs.
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        return require('expo-file-system/legacy');
+    }
+    catch {
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        return require('expo-file-system');
+    }
+}
+/** True when the deps the voice stream needs (expo-file-system + buffer)
+ *  are installed. The feedback UI hides the mic button otherwise. */
+function isVoiceStreamSupported() {
+    try {
+        loadBuffer();
+        const fs = loadFS();
+        return typeof fs?.readAsStringAsync === 'function';
+    }
+    catch {
+        return false;
+    }
+}
+class SDKVoiceSession {
+    constructor(callbacks) {
+        this.ws = null;
+        this.ttsChunks = [];
+        this.ttsTotalBytes = 0;
+        this.ttsSampleRate = 22050;
+        this.closed = false;
+        this.callbacks = callbacks;
+    }
+    /** Open the WS and send the start frame. Resolves once open. */
+    async start(opts) {
+        return new Promise((resolve, reject) => {
+            let opened = false;
+            let ws;
+            try {
+                // RN-specific 3rd arg carries request headers.
+                ws = new WebSocket(opts.wsUrl, undefined, { headers: opts.headers });
+            }
+            catch (e) {
+                reject(e);
+                return;
+            }
+            this.ws = ws;
+            ws.onopen = () => {
+                opened = true;
+                try {
+                    ws.send(JSON.stringify({
+                        type: 'start',
+                        project: opts.project ?? '',
+                        model: opts.model ?? '',
+                        runner: opts.runner ?? '',
+                        surface: opts.surface ?? '',
+                        ttsBudget: opts.ttsBudget ?? 0,
+                        sttProvider: opts.sttProvider ?? '',
+                        ttsProvider: opts.ttsProvider ?? '',
+                    }));
+                    resolve();
+                }
+                catch (e) {
+                    reject(e);
+                }
+            };
+            ws.onmessage = (e) => this.handleMessage(e);
+            ws.onerror = () => {
+                if (!opened)
+                    reject(new Error('voice WS connect failed'));
+                else
+                    this.callbacks.onError?.('voice WS error');
+            };
+            ws.onclose = () => {
+                this.closed = true;
+                if (!opened)
+                    reject(new Error('voice WS closed before open'));
+            };
+        });
+    }
+    /** Stream a recorded WAV/PCM file as binary frames. Records produced by
+     *  recordPcmWav() are LPCM 16-bit/16kHz mono with a 44-byte RIFF header
+     *  we strip here — the exact shape the backend → STT expects. */
+    async streamAudioFile(uri, opts) {
+        if (!this.ws || this.closed)
+            throw new Error('voice WS not open');
+        const Buffer = loadBuffer();
+        const FileSystem = loadFS();
+        const skipWavHeader = opts?.skipWavHeader ?? true;
+        const chunkBytes = opts?.chunkBytes ?? 16384;
+        const b64 = await FileSystem.readAsStringAsync(uri, { encoding: 'base64' });
+        let buf = Buffer.from(b64, 'base64');
+        if (skipWavHeader && buf.length > 44 && buf.slice(0, 4).toString() === 'RIFF') {
+            buf = buf.slice(44);
+        }
+        for (let i = 0; i < buf.length; i += chunkBytes) {
+            if (this.closed)
+                return;
+            const slice = buf.slice(i, Math.min(i + chunkBytes, buf.length));
+            this.ws.send(slice.buffer.slice(slice.byteOffset, slice.byteOffset + slice.byteLength));
+            await new Promise((r) => setTimeout(r, 0));
+        }
+    }
+    /** Done speaking — flush STT and create the agent task. */
+    finalize() {
+        if (this.ws && !this.closed) {
+            this.ws.send(JSON.stringify({ type: 'stop' }));
+        }
+    }
+    close() {
+        this.closed = true;
+        try {
+            this.ws?.close();
+        }
+        catch { /* ignore */ }
+        this.ws = null;
+    }
+    handleMessage(e) {
+        let msg;
+        try {
+            msg = JSON.parse(typeof e.data === 'string' ? e.data : '');
+        }
+        catch {
+            return;
+        }
+        switch (msg.type) {
+            case 'providers':
+                this.callbacks.onProviders?.(msg.stt ?? '', msg.tts ?? '');
+                break;
+            case 'transcript-partial':
+                this.callbacks.onTranscriptPartial?.(msg.text ?? '');
+                break;
+            case 'transcript-final':
+                this.callbacks.onTranscriptFinal?.(msg.text ?? '');
+                break;
+            case 'task-created':
+                this.callbacks.onTaskCreated?.(msg.taskId ?? '');
+                break;
+            case 'task-result':
+                this.callbacks.onTaskResult?.(msg.taskId ?? '', msg.text ?? '', msg.status ?? '');
+                break;
+            case 'tts-frame': {
+                if (!msg.pcm)
+                    break;
+                const Buffer = loadBuffer();
+                const arr = new Uint8Array(Buffer.from(msg.pcm, 'base64'));
+                this.ttsChunks.push(arr);
+                this.ttsTotalBytes += arr.length;
+                if (msg.sampleRate)
+                    this.ttsSampleRate = msg.sampleRate;
+                break;
+            }
+            case 'done': {
+                if (this.ttsTotalBytes > 0) {
+                    const pcm = new Uint8Array(this.ttsTotalBytes);
+                    let off = 0;
+                    for (const c of this.ttsChunks) {
+                        pcm.set(c, off);
+                        off += c.length;
+                    }
+                    this.callbacks.onTTSReady?.(pcm, this.ttsSampleRate);
+                }
+                this.callbacks.onDone?.();
+                this.close();
+                break;
+            }
+            case 'error':
+                this.callbacks.onError?.(msg.error ?? 'voice error');
+                break;
+        }
+    }
+}
+exports.SDKVoiceSession = SDKVoiceSession;
+/** Wrap raw PCM (signed 16-bit LE) in a minimal WAV container for
+ *  expo-av playback. 44-byte header + samples. */
+function wrapPCMAsWAV(pcm, sampleRate, channels = 1) {
+    const bitsPerSample = 16;
+    const byteRate = (sampleRate * channels * bitsPerSample) / 8;
+    const blockAlign = (channels * bitsPerSample) / 8;
+    const dataSize = pcm.length;
+    const buf = new Uint8Array(44 + dataSize);
+    const dv = new DataView(buf.buffer);
+    buf[0] = 0x52;
+    buf[1] = 0x49;
+    buf[2] = 0x46;
+    buf[3] = 0x46; // RIFF
+    dv.setUint32(4, 36 + dataSize, true);
+    buf[8] = 0x57;
+    buf[9] = 0x41;
+    buf[10] = 0x56;
+    buf[11] = 0x45; // WAVE
+    buf[12] = 0x66;
+    buf[13] = 0x6d;
+    buf[14] = 0x74;
+    buf[15] = 0x20; // "fmt "
+    dv.setUint32(16, 16, true);
+    dv.setUint16(20, 1, true);
+    dv.setUint16(22, channels, true);
+    dv.setUint32(24, sampleRate, true);
+    dv.setUint32(28, byteRate, true);
+    dv.setUint16(32, blockAlign, true);
+    dv.setUint16(34, bitsPerSample, true);
+    buf[36] = 0x64;
+    buf[37] = 0x61;
+    buf[38] = 0x74;
+    buf[39] = 0x61; // data
+    dv.setUint32(40, dataSize, true);
+    buf.set(pcm, 44);
+    return buf;
+}
+/** Write a PCM buffer to a temp WAV file; returns its file:// URI. */
+async function pcmToTempWavURI(pcm, sampleRate) {
+    const Buffer = loadBuffer();
+    const FileSystem = loadFS();
+    const wav = wrapPCMAsWAV(pcm, sampleRate);
+    const b64 = Buffer.from(wav).toString('base64');
+    const dir = FileSystem.cacheDirectory ?? FileSystem.documentDirectory ?? '';
+    const path = `${dir}yaver-voice-tts-${Date.now()}.wav`;
+    await FileSystem.writeAsStringAsync(path, b64, { encoding: 'base64' });
+    return path;
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "yaver-feedback-react-native",
-  "version": "0.8.13",
-  "description": "Visual feedback SDK for Yaver \u2014 bug reports, screen recording, voice annotations, and local-first developer workflows",
+  "version": "0.9.2",
+  "description": "Visual feedback SDK for Yaver — bug reports, screen recording, voice vibe coding, and local-first developer workflows",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [
@@ -26,9 +26,20 @@
     "expo-document-picker": ">=13.0.0",
     "react-native-view-shot": ">=3.0.0",
     "react-native-record-screen": ">=0.0.10",
-    "expo-av": ">=14.0.0"
+    "expo-av": ">=14.0.0",
+    "expo-file-system": ">=16.0.0",
+    "expo-speech": ">=12.0.0"
+  },
+  "dependencies": {
+    "buffer": "^6.0.3"
   },
   "peerDependenciesMeta": {
+    "expo-file-system": {
+      "optional": true
+    },
+    "expo-speech": {
+      "optional": true
+    },
     "@expo/config-plugins": {
       "optional": true
     },

package/src/BlackBox.ts

@@ -66,6 +66,13 @@ export interface BlackBoxCommand {
 /** Callback type for handling agent commands. */
 export type CommandHandler = (cmd: BlackBoxCommand) => void;
 
+function unrefTimer(timer: ReturnType<typeof setTimeout> | ReturnType<typeof setInterval>): void {
+  const maybeNodeTimer = timer as unknown as { unref?: () => void };
+  if (typeof maybeNodeTimer.unref === 'function') {
+    maybeNodeTimer.unref();
+  }
+}
+
 export class BlackBox {
   private static baseUrl: string | null = null;
   private static authToken: string | null = null;
@@ -109,7 +116,7 @@ export class BlackBox {
 
     BlackBox.baseUrl = feedbackConfig.agentUrl.replace(/\/$/, '');
     BlackBox.authToken = feedbackConfig.authToken ?? null;
-    BlackBox.relayPassword = (feedbackConfig as { relayPassword?: string }).relayPassword ?? '';
+    BlackBox.relayPassword = YaverFeedback.getRelayPassword();
     BlackBox.deviceId = config?.deviceId ?? BlackBox.generateDeviceId();
     BlackBox.appName = config?.appName ?? '';
     BlackBox.flushInterval = config?.flushInterval ?? 2000;
@@ -120,6 +127,7 @@ export class BlackBox {
     // Start periodic flush
     if (BlackBox.flushTimer) clearInterval(BlackBox.flushTimer);
     BlackBox.flushTimer = setInterval(() => BlackBox.flush(), BlackBox.flushInterval);
+    unrefTimer(BlackBox.flushTimer);
 
     // Log the session start
     BlackBox.push({
@@ -471,6 +479,7 @@ export class BlackBox {
       BlackBox.sseReconnectTimer = null;
       if (BlackBox.started) BlackBox.connectSSE();
     }, 5000);
+    unrefTimer(BlackBox.sseReconnectTimer);
   }
 
   // ─── Internal ────────────────────────────────────────────────────