yaver-feedback-react-native 0.9.0 → 0.9.3

package/src/storeShots.ts

@@ -0,0 +1,189 @@
+/**
+ * On-device App Store screenshot capture (Engine 2).
+ *
+ * The desktop `yaver shots` flow drives a simulator with Maestro. This is
+ * the in-app counterpart: the SDK, living inside the real running app,
+ * walks the app's own routes and screenshots each one with
+ * `react-native-view-shot`, then uploads the frames to the Yaver agent
+ * (POST /shots/upload). The agent normalizes them and runs the same App
+ * Store Connect backend (upload → metadata → submit).
+ *
+ * Why this exists alongside the simulator path: it captures *real device*
+ * pixels, knows the exact route map (no heuristics), and the user is
+ * already authenticated — so it sidesteps the i18n / no-testID fragility
+ * that makes a blind simulator walk hard.
+ *
+ * The host wires it once by handing us a navigation ref (react-navigation
+ * or expo-router router) plus the ordered list of routes to visit.
+ */
+
+import { captureScreenshotBase64 } from './capture';
+
+export interface StoreShotFrame {
+  route: string;
+  base64: string;
+  mimeType: string;
+}
+
+export interface CaptureStoreScreenshotsOptions {
+  /** Yaver agent base URL (e.g. http://192.168.1.5:18080 or a relay URL). */
+  agentUrl: string;
+  /** Bearer token for the agent (same-user envelope). */
+  authToken: string;
+  /** Relay password — required only when agentUrl is relay-routed. */
+  relayPassword?: string;
+
+  /** App name (vault scope / job label on the agent side). */
+  app: string;
+  /** iOS bundle id; the agent falls back to app.json if omitted. */
+  bundleId?: string;
+  /** App Store localization (default en-US). */
+  locale?: string;
+  /** When true, the agent also sets metadata + attempts submit-for-review. */
+  submit?: boolean;
+
+  /**
+   * Navigation handle. Either a react-navigation ref (has `.navigate`) or
+   * an expo-router `router` (has `.push`/`.navigate`). We call the first
+   * available method with the route string.
+   */
+  navigationRef?: any;
+  /** Ordered routes to visit + screenshot (e.g. ['/(tabs)/dashboard', ...]). */
+  routes: string[];
+
+  /** Optional per-route screenshot names (defaults to NN_<sanitized route>). */
+  screens?: string[];
+  /** Milliseconds to wait after navigating before capturing (default 900). */
+  settleMs?: number;
+  /** Hook the host can use to hide its own overlay before each capture. */
+  onBeforeCapture?: (route: string, index: number) => void | Promise<void>;
+}
+
+export interface CaptureStoreScreenshotsResult {
+  ok: boolean;
+  captured: number;
+  uploaded: number;
+  submitted?: boolean;
+  staged?: boolean;
+  message?: string;
+}
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((r) => setTimeout(r, ms));
+}
+
+function navigateTo(navRef: any, route: string): void {
+  if (!navRef) return;
+  // react-navigation ref
+  if (typeof navRef.navigate === 'function') {
+    navRef.navigate(route as never);
+    return;
+  }
+  // expo-router router
+  if (typeof navRef.push === 'function') {
+    navRef.push(route);
+    return;
+  }
+  if (navRef.current && typeof navRef.current.navigate === 'function') {
+    navRef.current.navigate(route as never);
+    return;
+  }
+}
+
+function shotName(route: string, index: number, override?: string): string {
+  if (override) return override;
+  const clean = route
+    .replace(/^\/+/, '')
+    .replace(/[()[\]/]+/g, '_')
+    .replace(/[^a-zA-Z0-9_]+/g, '')
+    .replace(/^_+|_+$/g, '');
+  const n = String(index + 1).padStart(2, '0');
+  return `${n}_${clean || 'screen'}`;
+}
+
+/**
+ * Walk the app's routes, screenshot each, and upload the batch to the
+ * agent. Returns a summary; never throws for a single missed route —
+ * it captures what it can and reports the count.
+ */
+export async function captureStoreScreenshots(
+  opts: CaptureStoreScreenshotsOptions,
+): Promise<CaptureStoreScreenshotsResult> {
+  if (!opts.agentUrl || !opts.authToken) {
+    return { ok: false, captured: 0, uploaded: 0, message: 'agentUrl + authToken required' };
+  }
+  if (!opts.routes?.length) {
+    return { ok: false, captured: 0, uploaded: 0, message: 'no routes to capture' };
+  }
+
+  const settleMs = opts.settleMs ?? 900;
+  const frames: StoreShotFrame[] = [];
+
+  for (let i = 0; i < opts.routes.length; i++) {
+    const route = opts.routes[i];
+    try {
+      navigateTo(opts.navigationRef, route);
+      await sleep(settleMs);
+      if (opts.onBeforeCapture) await opts.onBeforeCapture(route, i);
+      const shot = await captureScreenshotBase64();
+      if (shot?.base64) {
+        frames.push({
+          route: shotName(route, i, opts.screens?.[i]),
+          base64: shot.base64,
+          mimeType: shot.mimeType,
+        });
+      }
+    } catch {
+      // Skip a route that failed to render — keep walking.
+    }
+  }
+
+  if (frames.length === 0) {
+    return { ok: false, captured: 0, uploaded: 0, message: 'captured no frames' };
+  }
+
+  const headers: Record<string, string> = {
+    Authorization: `Bearer ${opts.authToken}`,
+    'Content-Type': 'application/json',
+  };
+  if (opts.relayPassword) headers['X-Relay-Password'] = opts.relayPassword;
+
+  const base = opts.agentUrl.replace(/\/$/, '');
+  try {
+    const resp = await fetch(`${base}/shots/upload`, {
+      method: 'POST',
+      headers,
+      body: JSON.stringify({
+        app: opts.app,
+        bundleId: opts.bundleId ?? '',
+        locale: opts.locale ?? 'en-US',
+        submit: !!opts.submit,
+        frames,
+      }),
+    });
+    const j = await resp.json().catch(() => ({}));
+    if (!resp.ok || j?.ok === false) {
+      return {
+        ok: false,
+        captured: frames.length,
+        uploaded: 0,
+        message: j?.error || `agent /shots/upload HTTP ${resp.status}`,
+      };
+    }
+    return {
+      ok: true,
+      captured: frames.length,
+      uploaded: typeof j?.uploaded === 'number' ? j.uploaded : frames.length,
+      submitted: j?.submitted,
+      staged: j?.staged,
+      message: j?.message,
+    };
+  } catch (e: any) {
+    return {
+      ok: false,
+      captured: frames.length,
+      uploaded: 0,
+      message: `upload failed: ${e?.message ?? 'network error'}`,
+    };
+  }
+}

package/src/types.ts

@@ -1,3 +1,8 @@
+// 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';
+import type { SDKDogfoodConfig } from './dogfoodPolicy';
+
 /**
  * Remote browser-style sign-in session for a coding-agent CLI on the
  * connected yaver host. Mirrors runnerBrowserAuthSession on the agent
@@ -32,6 +37,8 @@ export interface RunnerAuthStatusRow {
   path?: string;
   detail?: string;
   version?: string;
+  isDefault?: boolean;
+  models?: Array<{ id: string; name?: string; provider?: string; isDefault?: boolean }>;
 }
 
 export interface OpenCodeProviderSummary {
@@ -122,9 +129,67 @@ 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;
+  /** Optional coding route. Defaults to agentUrl. */
+  codingAgentUrl?: string;
+  /** Optional render/reload route. Defaults to codingAgentUrl/agentUrl. */
+  renderAgentUrl?: string;
+  /** Device identities shown in the unified Settings card when routes differ. */
+  codingDeviceId?: string;
+  renderDeviceId?: string;
+  /**
+   * Show the small "Y" mark while this app is running INSIDE Yaver's container
+   * (a Hermes-pushed development bundle), so a tester can tell it apart from
+   * the build they installed — and can find the way back.
+   *
+   * DEFAULT TRUE. The failure it prevents is silent and lands on a tester
+   * rather than a developer: an app that looks installed but is someone's
+   * branch produces "bug reports" against unfinished work, and a tester with
+   * no visible way out is simply stuck. That class should not be opt-in.
+   *
+   * Costs nothing in a standalone build — outside Yaver's container the badge
+   * renders null (the YaverInfo native module is absent), so shipping with it
+   * enabled has no effect on what your users see.
+   *
+   * Set false if your app already shows its own in-container indicator, or if
+   * a pixel-exact surface cannot spare 22 points in a corner.
+   */
+  modeBadge?: boolean;
+  /** Corner for the mode badge. Default 'bottom-left' — bottom-right is where
+   *  most apps put a FAB, and the badge must never compete with the app's own
+   *  primary action. */
+  modeBadgePosition?: 'bottom-left' | 'bottom-right' | 'top-left' | 'top-right';
+  /** Account-scoped direct Dogfood UX for an approved third-party app.
+   * When the current app account is allowlisted, the small Y opens Vibing
+   * directly instead of the normal feedback actions. This is a client UX gate,
+   * never an authentication mechanism; agent calls still require Yaver auth. */
+  dogfood?: SDKDogfoodConfig;
+  /**
+   * 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
@@ -164,6 +229,47 @@ 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;
+  /**
+   * Opt in to the microphone/STT controls in the feedback Vibing card.
+   *
+   * This is deliberately false unless explicitly enabled: ordinary phone
+   * and tablet surfaces stay keyboard-first. Car/watch-style hosts that are
+   * inherently voice-driven may set this to true.
+   */
+  voiceInputEnabled?: boolean;
   /** How feedback collection is triggered */
   trigger?: 'shake' | 'floating-button' | 'manual';
   /**
@@ -204,6 +310,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.
@@ -289,6 +411,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
@@ -368,13 +510,6 @@ export interface FeedbackConfig {
    * Default: false (preserve historical behavior).
    */
   strictNativeAuth?: boolean;
-  /**
-   * Optional host invite code to prefill into the in-SDK guest onboarding
-   * flow. Useful when your app receives the code from a deep link, QR flow,
-   * or an out-of-band host handoff and you want the user to redeem it
-   * without typing.
-   */
-  guestInviteCode?: string;
 }
 
 export interface FeedbackBundle {
@@ -404,9 +539,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 {
@@ -415,6 +577,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 {
@@ -423,6 +587,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;

package/dist/GuestOnboardingScreen.d.ts

@@ -1,8 +0,0 @@
-import React from 'react';
-export interface YaverGuestOnboardingScreenProps {
-    token: string;
-    initialInviteCode?: string;
-    onContinue: () => void;
-    onCancel?: () => void;
-}
-export declare const YaverGuestOnboardingScreen: React.FC<YaverGuestOnboardingScreenProps>;