yaver-feedback-react-native 0.8.13 → 0.9.2

package/dist/VibeChatScreen.js

@@ -53,7 +53,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.VibeChatScreen = VibeChatScreen;
 const react_1 = __importStar(require("react"));
 const react_native_1 = require("react-native");
-function VibeChatScreen({ client, initialTaskId, initialUserPrompt, onClose, onReload, }) {
+const voice_1 = require("./voice");
+const capture_1 = require("./capture");
+function VibeChatScreen({ client, initialTaskId, initialUserPrompt, onClose, onReload, project, model, runner, }) {
     const [taskId, setTaskId] = (0, react_1.useState)(initialTaskId);
     const [turns, setTurns] = (0, react_1.useState)(() => [
         {
@@ -76,6 +78,16 @@ function VibeChatScreen({ client, initialTaskId, initialUserPrompt, onClose, onR
     const [isReloading, setIsReloading] = (0, react_1.useState)(false);
     const scrollRef = (0, react_1.useRef)(null);
     const abortRef = (0, react_1.useRef)(null);
+    // ── Voice vibe coding ──────────────────────────────────────────────
+    const [voiceState, setVoiceState] = (0, react_1.useState)('idle');
+    const [voiceAvailable, setVoiceAvailable] = (0, react_1.useState)(false);
+    // "local" = whisper.cpp on the host (free, private); "flux" = Deepgram
+    // nova-3 streaming. fluxAvailable gates the toggle on whether the agent
+    // has a Deepgram key. activeEngine is echoed back by the agent.
+    const [voiceMode, setVoiceMode] = (0, react_1.useState)('local');
+    const [fluxAvailable, setFluxAvailable] = (0, react_1.useState)(false);
+    const [activeEngine, setActiveEngine] = (0, react_1.useState)('');
+    const voiceSessionRef = (0, react_1.useRef)(null);
     // Subscribe to the current task's SSE stream. Re-runs whenever the
     // taskId changes (resumeTask reuses the same id, so this only fires
     // once per task — which is fine).
@@ -195,6 +207,170 @@ function VibeChatScreen({ client, initialTaskId, initialUserPrompt, onClose, onR
             setIsReloading(false);
         }
     }, [isReloading, onReload]);
+    // Probe whether voice is usable: deps present (expo-av + expo-file-
+    // system + buffer) AND the agent reports STT/TTS ready. Hide the mic
+    // entirely otherwise so users never tap a dead button.
+    (0, react_1.useEffect)(() => {
+        let cancelled = false;
+        (async () => {
+            if (!(0, capture_1.isVoiceCaptureSupported)() || !(0, voice_1.isVoiceStreamSupported)())
+                return;
+            try {
+                const res = await fetch(`${client.agentBaseUrl}/voice/status`, { headers: client.voiceAuthHeaders() });
+                if (!res.ok)
+                    return;
+                const body = await res.json();
+                if (cancelled)
+                    return;
+                // Local whisper is always usable when voice is enabled; Flux needs
+                // a Deepgram key on the agent. Show the mic if either path works.
+                const localOk = !!body?.enabled;
+                const fluxOk = !!body?.enabled && !!body?.deepgramSet;
+                if (localOk || fluxOk)
+                    setVoiceAvailable(true);
+                setFluxAvailable(fluxOk);
+                if (!localOk && fluxOk)
+                    setVoiceMode('flux');
+            }
+            catch { /* leave hidden */ }
+        })();
+        return () => { cancelled = true; };
+    }, [client]);
+    (0, react_1.useEffect)(() => () => { voiceSessionRef.current?.close(); }, []);
+    // Local TTS: the agent streams no audio for "local"/"device" engines,
+    // so the client speaks the result text with the device synthesizer.
+    // expo-speech is optional — if absent, the text is still shown.
+    const speakLocalText = (0, react_1.useCallback)((text) => {
+        if (!text)
+            return;
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-var-requires
+            const Speech = require('expo-speech');
+            const headline = text.length > 280 ? `${text.slice(0, 280)} — see screen for the rest.` : text;
+            Speech.stop?.();
+            Speech.speak?.(headline);
+        }
+        catch { /* expo-speech not installed — text remains visible */ }
+    }, []);
+    const playTTS = (0, react_1.useCallback)(async (pcm, sampleRate) => {
+        try {
+            const wavUri = await (0, voice_1.pcmToTempWavURI)(pcm, sampleRate);
+            // eslint-disable-next-line @typescript-eslint/no-var-requires
+            const { Audio } = require('expo-av');
+            const { sound } = await Audio.Sound.createAsync({ uri: wavUri }, { shouldPlay: true });
+            sound.setOnPlaybackStatusUpdate((st) => {
+                if (st.didJustFinish)
+                    sound.unloadAsync().catch(() => { });
+            });
+        }
+        catch { /* playback best-effort */ }
+    }, []);
+    const stopVoiceAndProcess = (0, react_1.useCallback)(async () => {
+        setVoiceState('uploading');
+        let uri = null;
+        try {
+            uri = await (0, capture_1.stopPcmRecording)();
+        }
+        catch (e) {
+            setVoiceState('idle');
+            setTurns((prev) => [...prev, { id: `status-verr-${Date.now()}`, role: 'status', text: `voice: ${e instanceof Error ? e.message : String(e)}`, timestamp: Date.now() }]);
+            return;
+        }
+        if (!uri) {
+            setVoiceState('idle');
+            return;
+        }
+        const useFlux = voiceMode === 'flux' && fluxAvailable;
+        const session = new voice_1.SDKVoiceSession({
+            onProviders: (stt, tts) => setActiveEngine(stt === 'deepgram' ? 'Flux (Deepgram)' : stt === 'local' ? 'Local (whisper)' : stt),
+            onTranscriptPartial: (t) => {
+                setTurns((prev) => {
+                    const next = prev.filter((x) => x.id !== 'voice-partial');
+                    next.push({ id: 'voice-partial', role: 'status', text: `🎙 ${t}`, timestamp: Date.now() });
+                    return next;
+                });
+            },
+            onTranscriptFinal: (t) => {
+                setVoiceState('thinking');
+                setTurns((prev) => [
+                    ...prev.filter((x) => x.id !== 'voice-partial'),
+                    { id: `user-voice-${Date.now()}`, role: 'user', text: t, timestamp: Date.now() },
+                    { id: `status-${Date.now()}`, role: 'status', text: 'thinking…', timestamp: Date.now() },
+                ]);
+            },
+            onTaskCreated: (id) => {
+                // Hand the chat's SSE subscription the new task so its agent
+                // output streams into the transcript exactly like a typed turn.
+                if (id) {
+                    setStatus('running');
+                    setStreamBuffer('');
+                    setTaskId(id);
+                }
+            },
+            onTaskResult: (_id, text) => {
+                setVoiceState('speaking');
+                // Local TTS path: agent sends no audio frames, so speak here.
+                if (!useFlux)
+                    speakLocalText(text);
+            },
+            onTTSReady: (pcm, sr) => { void playTTS(pcm, sr); },
+            onDone: () => setTimeout(() => setVoiceState('idle'), 1200),
+            onError: (msg) => {
+                setVoiceState('idle');
+                setTurns((prev) => [...prev.filter((x) => x.id !== 'voice-partial'), { id: `status-verr-${Date.now()}`, role: 'status', text: `voice: ${msg}`, timestamp: Date.now() }]);
+            },
+        });
+        voiceSessionRef.current = session;
+        try {
+            await session.start({
+                wsUrl: client.voiceStreamUrl(),
+                headers: client.voiceAuthHeaders(),
+                project,
+                model,
+                runner,
+                surface: 'feedback-sdk',
+                ttsBudget: 280,
+                // Local: whisper.cpp on the host + device synth. Flux: Deepgram
+                // nova-3 STT + Aura TTS streamed back as PCM.
+                sttProvider: useFlux ? 'deepgram' : 'local',
+                ttsProvider: useFlux ? 'deepgram' : 'local',
+            });
+            await session.streamAudioFile(uri, { skipWavHeader: true });
+            session.finalize();
+        }
+        catch (e) {
+            setVoiceState('idle');
+            session.close();
+            setTurns((prev) => [...prev, { id: `status-verr-${Date.now()}`, role: 'status', text: `voice: ${e instanceof Error ? e.message : String(e)}`, timestamp: Date.now() }]);
+        }
+    }, [client, project, model, runner, playTTS, voiceMode, fluxAvailable, speakLocalText]);
+    const handleVoicePress = (0, react_1.useCallback)(async () => {
+        if (voiceState === 'recording') {
+            void stopVoiceAndProcess();
+            return;
+        }
+        if (voiceState !== 'idle') {
+            // Mid-flow tap cancels.
+            voiceSessionRef.current?.close();
+            voiceSessionRef.current = null;
+            setVoiceState('idle');
+            return;
+        }
+        try {
+            await (0, capture_1.startPcmRecording)();
+            setVoiceState('recording');
+        }
+        catch (e) {
+            setTurns((prev) => [...prev, { id: `status-verr-${Date.now()}`, role: 'status', text: `voice: ${e instanceof Error ? e.message : String(e)}`, timestamp: Date.now() }]);
+        }
+    }, [voiceState, stopVoiceAndProcess]);
+    const voiceLabel = {
+        idle: '🎙 speak',
+        recording: '■ stop',
+        uploading: 'sending…',
+        thinking: 'thinking…',
+        speaking: 'speaking…',
+    };
     return (<react_native_1.View style={styles.container}>
       <react_native_1.View style={styles.header}>
         <react_native_1.Text style={styles.title}>Vibe</react_native_1.Text>
@@ -226,8 +402,30 @@ function VibeChatScreen({ client, initialTaskId, initialUserPrompt, onClose, onR
       </react_native_1.ScrollView>
 
       <react_native_1.View style={styles.footer}>
+        {voiceAvailable && voiceState !== 'idle' && (<react_native_1.Text style={styles.engineCaption}>
+            {voiceState === 'recording' ? 'listening' : voiceState === 'uploading' ? 'sending' : voiceState === 'thinking' ? 'agent working' : 'speaking'}
+            {activeEngine ? ` · ${activeEngine}` : ` · ${voiceMode === 'flux' ? 'Flux (Deepgram)' : 'Local (whisper)'}`}
+          </react_native_1.Text>)}
         <react_native_1.TextInput style={styles.input} value={followUp} onChangeText={setFollowUp} placeholder={status === 'running' ? 'wait for the agent…' : 'follow up…'} placeholderTextColor="#666" editable={status !== 'running' && !isResuming} multiline/>
         <react_native_1.View style={styles.actions}>
+          {voiceAvailable && (<>
+              {/* Local ↔ Flux engine toggle. Only shows Flux when the
+                agent has a Deepgram key; otherwise the label just
+                states "Local" so the active engine is always clear. */}
+              {fluxAvailable ? (<react_native_1.TouchableOpacity style={[styles.actionBtn, styles.engineToggle]} onPress={() => setVoiceMode((m) => (m === 'local' ? 'flux' : 'local'))} disabled={voiceState !== 'idle'} accessibilityLabel="Toggle voice engine">
+                  <react_native_1.Text style={styles.engineToggleText}>{voiceMode === 'flux' ? '⚡ Flux' : '🔒 Local'}</react_native_1.Text>
+                </react_native_1.TouchableOpacity>) : (<react_native_1.View style={[styles.actionBtn, styles.engineToggle]}>
+                  <react_native_1.Text style={styles.engineToggleText}>🔒 Local</react_native_1.Text>
+                </react_native_1.View>)}
+              <react_native_1.TouchableOpacity style={[
+                styles.actionBtn,
+                styles.voiceBtn,
+                voiceState === 'recording' && styles.voiceBtnActive,
+                (voiceState === 'uploading' || voiceState === 'thinking' || voiceState === 'speaking') && styles.actionBtnDisabled,
+            ]} onPress={handleVoicePress} disabled={voiceState === 'uploading' || voiceState === 'thinking' || voiceState === 'speaking'} accessibilityLabel="Vibe code by voice">
+                <react_native_1.Text style={styles.actionText}>{voiceLabel[voiceState]}</react_native_1.Text>
+              </react_native_1.TouchableOpacity>
+            </>)}
           {onReload && (<react_native_1.TouchableOpacity style={[
                 styles.actionBtn,
                 styles.reloadBtn,
@@ -323,6 +521,11 @@ const styles = react_native_1.StyleSheet.create({
     },
     actionBtnDisabled: { opacity: 0.5 },
     reloadBtn: { backgroundColor: 'rgba(255,255,255,0.08)' },
+    voiceBtn: { backgroundColor: 'rgba(16,185,129,0.18)' },
+    voiceBtnActive: { backgroundColor: '#ef4444' },
+    engineToggle: { backgroundColor: 'rgba(255,255,255,0.06)', marginRight: 'auto', marginLeft: 0 },
+    engineToggleText: { color: '#cbd5e1', fontSize: 12, fontWeight: '600' },
+    engineCaption: { color: '#9ca3af', fontSize: 11, marginBottom: 6, marginLeft: 4 },
     sendBtn: { backgroundColor: '#7582f5' },
     actionText: { color: '#fff', fontSize: 13, fontWeight: '600' },
 });

package/dist/YaverFeedback.d.ts

@@ -1,5 +1,6 @@
 import { FeedbackConfig, CapturedError } from './types';
 import { P2PClient } from './P2PClient';
+import { CaptureStoreScreenshotsOptions, CaptureStoreScreenshotsResult } from './storeShots';
 import { QuickIconColorPreset } from './preferences';
 /**
  * Main entry point for the Yaver Feedback SDK.
@@ -15,7 +16,26 @@ export declare class YaverFeedback {
      * If no `agentUrl` is provided, the SDK will attempt auto-discovery
      * via `YaverDiscovery` on the first `startReport()` call.
      */
+    /** The runtime lane, when running on web inside a Yaver preview WebView. */
+    static detectWebLane(): 'browser' | 'webrtc' | null;
+    /**
+     * Mount a draggable DOM floating "Y" icon for the BROWSER lane (RN-web). It
+     * lives in the WebView's document.body (position:fixed, max z-index), so it
+     * renders ON TOP of the page inside the WebView and is never occluded by the
+     * fullScreen preview modal — the one occlusion-proof affordance on iOS.
+     * Tap opens the SDK's existing report flow (the RN FeedbackModal renders in
+     * the same WebView DOM, also un-occluded). No-op off-web or off-lane, and
+     * idempotent (a re-init reuses the existing node).
+     */
+    static mountBrowserLaneIcon(): void;
     static init(cfg: FeedbackConfig): void;
+    /**
+     * Opt-in global crash handler. This wraps the existing React Native
+     * ErrorUtils handler and still calls it, so Sentry/Crashlytics/Bugsnag can
+     * remain the system of record. The SDK only uploads a crash report and,
+     * when configured, asks the agent to create a fix task.
+     */
+    static installCrashHandler(): void;
     /**
      * Run agent discovery in the background.
      * Called automatically from init() when no agentUrl is provided.
@@ -46,6 +66,29 @@ export declare class YaverFeedback {
     static setAuthToken(token: string): Promise<void>;
     /** Returns true once the SDK has a session token it can use. */
     static isAuthed(): boolean;
+    /**
+     * On-device App Store screenshot capture (Engine 2). Walks the routes
+     * the host hands us, screenshots each, and uploads to the agent which
+     * runs the App Store Connect backend. agentUrl / authToken / relay
+     * password default to the SDK's resolved session; the host only has to
+     * supply a navigation ref + the ordered route list.
+     *
+     *   YaverFeedback.captureStoreScreenshots({
+     *     app: 'sfmg',
+     *     navigationRef,
+     *     routes: ['/(tabs)/dashboard', '/(tabs)/messages', '/(tabs)/clients'],
+     *     submit: true,
+     *   })
+     */
+    static captureStoreScreenshots(opts: Omit<CaptureStoreScreenshotsOptions, 'agentUrl' | 'authToken' | 'relayPassword'> & Partial<Pick<CaptureStoreScreenshotsOptions, 'agentUrl' | 'authToken' | 'relayPassword'>>): Promise<CaptureStoreScreenshotsResult>;
+    /**
+     * Let the mobile app / CLI kick THIS device into self-capturing. Registers
+     * a BlackBox command listener that fires captureStoreScreenshots when the
+     * agent pushes a `capture_store_shots` command (its `data` may override
+     * `submit` / `locale`). Returns an unsubscribe fn. Call once after init,
+     * passing the app's navigation ref + the routes to walk.
+     */
+    static enableStoreShotsOnCommand(opts: Omit<CaptureStoreScreenshotsOptions, 'agentUrl' | 'authToken' | 'relayPassword'>): () => void;
     /**
      * Request the embedded FeedbackModal to show the login screen. Works by
      * emitting an event the modal listens for — avoids forcing the host app
@@ -112,6 +155,46 @@ export declare class YaverFeedback {
      * - All methods become active
      */
     static setEnabled(value: boolean): void;
+    /**
+     * Turn shake-to-report on or off without tearing the SDK down.
+     *
+     * `trigger` is read only inside init(), so before this the only ways to
+     * stop listening for a shake were setEnabled(false) — which also kills the
+     * flight recorder and the agent command channel — or a re-init, which used
+     * to stack a duplicate command handler. Neither is what "turn the shake
+     * catcher off" should cost.
+     *
+     * Persists onto config.disableShakeGesture, so a later setEnabled(true)
+     * honours it rather than resurrecting the listener.
+     */
+    static setShakeEnabled(value: boolean): void;
+    /** Whether the shake listener is currently armed. */
+    static isShakeEnabled(): boolean;
+    /**
+     * Bring the shake listener in line with the current config. Idempotent —
+     * safe to call whenever `enabled`, `trigger`, or `disableShakeGesture`
+     * moves.
+     */
+    private static syncShakeDetector;
+    private static stopShakeDetector;
+    /** Cancel a pending BlackBox auto-start retry chain. */
+    private static cancelBlackBoxAutoStart;
+    /**
+     * Start BlackBox as soon as we have BOTH an agentUrl and a token, polling
+     * until then.
+     *
+     * Both conditions are mandatory and deliberate: starting without a token
+     * makes the SSE channel 401 and retry with backoff, which is the tight
+     * string-concat + JSON-parse loop that used to SIGSEGV Hermes on iOS 18.3.1
+     * during Screenshot & Fix. This only re-checks that same guard over time.
+     *
+     * Bounded at ~60s: long enough for AsyncStorage hydration plus a Convex
+     * discovery round trip on a cold, off-LAN start, short enough that a device
+     * whose user never signs in stops polling. Giving up here costs nothing —
+     * setAuthToken() and startReport() both reschedule, so signing in later
+     * still brings the channel up.
+     */
+    private static scheduleBlackBoxAutoStart;
     /** Returns whether the SDK is currently enabled. */
     static isEnabled(): boolean;
     /** Returns the current config, or null if not initialized. */
@@ -150,6 +233,21 @@ export declare class YaverFeedback {
      * // wrapper, and the chain stays intact.
      */
     static wrapErrorHandler(next?: ((error: Error, isFatal?: boolean) => void) | null): (error: Error, isFatal?: boolean) => void;
+    /**
+     * Upload a crash-aware feedback bundle. Apps can call this from their own
+     * error boundary/global handler. If crashReporting.autoFix is true, the SDK
+     * also triggers the agent's feedback-fix task; reload delivery still happens
+     * through the existing BlackBox command stream.
+     */
+    static reportCrash(error: Error, opts?: {
+        isFatal?: boolean;
+        source?: 'manual' | 'global-handler';
+        metadata?: Record<string, unknown>;
+        autoFix?: boolean;
+    }): Promise<{
+        reportId?: string;
+        taskId?: string;
+    }>;
     /**
      * Returns the P2P client instance.
      * Available after init if agentUrl is set, or after first successful discovery.