yaver-feedback-react-native 0.8.13 → 0.9.0

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.0",
+  "description": "Visual feedback SDK for Yaver \u2014 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
     },