yaver-feedback-react-native 0.8.13 → 0.9.2

package/src/types.ts

@@ -1,3 +1,7 @@
+// Type-only: BlackBox.ts already imports from this module, so a value import
+// would close a cycle. `import type` is erased at compile time.
+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
@@ -20,6 +24,49 @@ export interface RunnerBrowserAuthSession {
   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;
@@ -79,9 +126,33 @@ 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
@@ -121,6 +192,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';
   /**
@@ -161,6 +265,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.
@@ -246,6 +366,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
@@ -361,9 +501,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 {
@@ -372,6 +539,8 @@ 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 {
@@ -380,6 +549,43 @@ export interface AppInfo {
   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;
@@ -451,12 +657,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/src/voice.ts

@@ -0,0 +1,270 @@
+// 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.
+
+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;
+}
+
+interface WireMsg {
+  type: string;
+  text?: string;
+  taskId?: string;
+  status?: string;
+  pcm?: string;
+  sampleRate?: number;
+  error?: string;
+  stt?: string;
+  tts?: string;
+}
+
+function loadBuffer(): any {
+  // eslint-disable-next-line @typescript-eslint/no-var-requires
+  return require('buffer').Buffer;
+}
+
+function loadFS(): any {
+  // 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. */
+export function isVoiceStreamSupported(): boolean {
+  try {
+    loadBuffer();
+    const fs = loadFS();
+    return typeof fs?.readAsStringAsync === 'function';
+  } catch {
+    return false;
+  }
+}
+
+export class SDKVoiceSession {
+  private ws: WebSocket | null = null;
+  private callbacks: SDKVoiceCallbacks;
+  private ttsChunks: Uint8Array[] = [];
+  private ttsTotalBytes = 0;
+  private ttsSampleRate = 22050;
+  private closed = false;
+
+  constructor(callbacks: SDKVoiceCallbacks) {
+    this.callbacks = callbacks;
+  }
+
+  /** Open the WS and send the start frame. Resolves once open. */
+  async start(opts: SDKVoiceStartOpts): Promise<void> {
+    return new Promise((resolve, reject) => {
+      let opened = false;
+      let ws: WebSocket;
+      try {
+        // RN-specific 3rd arg carries request headers.
+        ws = new (WebSocket as any)(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: any) => 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: string, opts?: { skipWavHeader?: boolean; chunkBytes?: number }): Promise<void> {
+    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(): void {
+    if (this.ws && !this.closed) {
+      this.ws.send(JSON.stringify({ type: 'stop' }));
+    }
+  }
+
+  close(): void {
+    this.closed = true;
+    try { this.ws?.close(); } catch { /* ignore */ }
+    this.ws = null;
+  }
+
+  private handleMessage(e: { data: any }): void {
+    let msg: WireMsg;
+    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;
+    }
+  }
+}
+
+/** Wrap raw PCM (signed 16-bit LE) in a minimal WAV container for
+ *  expo-av playback. 44-byte header + samples. */
+export function wrapPCMAsWAV(pcm: Uint8Array, sampleRate: number, channels = 1): Uint8Array {
+  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. */
+export async function pcmToTempWavURI(pcm: Uint8Array, sampleRate: number): Promise<string> {
+  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;
+}