yaver-feedback-react-native 0.6.1 → 0.7.1

package/src/deviceDedup.ts

@@ -0,0 +1,184 @@
+/**
+ * Device deduplication + online-signal merging, ported from the Yaver
+ * mobile app's DeviceContext.collapseAliasDevices.
+ *
+ * Convex stores one row per pair (device, re-install). After a re-pair
+ * or hostname change the list can contain 2-3 rows for the same
+ * physical machine, with different hwid/publicKey values. The picker
+ * then shows duplicates and the user can't tell which one is live.
+ *
+ * This file collapses rows in three passes:
+ *   1. Identity key (hwid → publicKey → "host:os:name" → id → name)
+ *   2. Alias key (os + normalized-hostname) — catches re-pairs that
+ *      mint a new hwid
+ *   3. Endpoint key (host:port)
+ *
+ * When collapsing, `mergeDeviceEntries` prefers: authenticated over
+ * needsAuth, online over offline, freshest lastHeartbeat.
+ */
+
+import type { RemoteDevice } from './auth';
+
+function normalizedName(name: string | undefined): string {
+  return String(name || '').trim().toLowerCase().replace(/\.local$/i, '');
+}
+
+function normalizedHost(host: string | undefined): string {
+  return String(host || '').trim().toLowerCase().replace(/\.local$/i, '');
+}
+
+function identityKey(d: RemoteDevice): string {
+  if (d.hwid) return `hwid:${d.hwid}`;
+  if (d.publicKey) return `pub:${d.publicKey}`;
+  if (d.isGuest) {
+    const scope = d.hostEmail || d.hostName || 'guest';
+    return `guest:${scope}:${d.deviceId || d.name}`;
+  }
+  const n = normalizedName(d.name);
+  const os = String(d.platform || '').trim().toLowerCase();
+  if (n && os) return `host:${os}:${n}`;
+  if (d.deviceId) return `id:${d.deviceId}`;
+  return `name:${d.name}`;
+}
+
+function aliasKey(d: RemoteDevice): string | null {
+  if (d.isGuest) return null;
+  const n = normalizedName(d.name);
+  const os = String(d.platform || '').trim().toLowerCase();
+  if (!n || !os) return null;
+  return `${os}:${n}`;
+}
+
+function endpointKey(d: RemoteDevice): string | null {
+  if (d.isGuest) return null;
+  const h = normalizedHost(d.quicHost);
+  if (!h) return null;
+  return `${h}:${d.quicPort || 0}`;
+}
+
+function mergeEntries(existing: RemoteDevice, incoming: RemoteDevice): RemoteDevice {
+  const incomingWins =
+    (!!existing.needsAuth && !incoming.needsAuth) ||
+    (incoming.lastHeartbeat || 0) > (existing.lastHeartbeat || 0) ||
+    (!!incoming.isOnline && !existing.isOnline);
+  const base = incomingWins ? incoming : existing;
+  const other = incomingWins ? existing : incoming;
+  return {
+    ...other,
+    ...base,
+    quicHost: base.quicHost || other.quicHost,
+    quicPort: base.quicPort || other.quicPort,
+    isOnline: base.isOnline || other.isOnline,
+    runnerDown: base.runnerDown && other.runnerDown,
+    publicKey: base.publicKey || other.publicKey,
+    lastHeartbeat: Math.max(existing.lastHeartbeat || 0, incoming.lastHeartbeat || 0),
+  };
+}
+
+// When two rows share the same alias key (hostname + OS) but differ on
+// hwid/publicKey, pick the active one over the stale needs-auth leftover.
+function pickActiveOverStaleNeedsAuth(a: RemoteDevice, b: RemoteDevice): RemoteDevice | null {
+  const aDead = a.needsAuth && !a.isOnline;
+  const bDead = b.needsAuth && !b.isOnline;
+  const aLive = !a.needsAuth && a.isOnline;
+  const bLive = !b.needsAuth && b.isOnline;
+  if (aDead && bLive) return b;
+  if (bDead && aLive) return a;
+  return null;
+}
+
+/**
+ * Collapse a Convex device list so each physical machine appears once.
+ * Safe on an empty list; idempotent on an already-deduped list.
+ */
+export function collapseRemoteDevices(devices: RemoteDevice[]): RemoteDevice[] {
+  if (!Array.isArray(devices) || devices.length === 0) return [];
+
+  const byIdentity = new Map<string, RemoteDevice>();
+  for (const d of devices) {
+    const k = identityKey(d);
+    const prev = byIdentity.get(k);
+    byIdentity.set(k, prev ? mergeEntries(prev, d) : d);
+  }
+
+  const byAlias = new Map<string, RemoteDevice>();
+  for (const d of byIdentity.values()) {
+    const k = aliasKey(d);
+    if (!k) {
+      byAlias.set(`id:${d.deviceId}`, d);
+      continue;
+    }
+    const prev = byAlias.get(k);
+    if (!prev) {
+      byAlias.set(k, d);
+      continue;
+    }
+    const strongIdentityConflict =
+      !!prev.publicKey && !!d.publicKey && prev.publicKey !== d.publicKey;
+    if (strongIdentityConflict) {
+      const winner = pickActiveOverStaleNeedsAuth(prev, d);
+      if (winner) {
+        byAlias.set(k, winner);
+        continue;
+      }
+    }
+    byAlias.set(k, mergeEntries(prev, d));
+  }
+
+  const byEndpoint = new Map<string, RemoteDevice>();
+  for (const d of byAlias.values()) {
+    const k = endpointKey(d);
+    if (!k) {
+      byEndpoint.set(`id:${d.deviceId}`, d);
+      continue;
+    }
+    const prev = byEndpoint.get(k);
+    byEndpoint.set(k, prev ? mergeEntries(prev, d) : d);
+  }
+
+  return [...byEndpoint.values()];
+}
+
+/**
+ * Threshold for "online" based on heartbeat age, in milliseconds.
+ * Matches the mobile app (HEARTBEAT_STALE_MS = 90 s). The SDK used
+ * 60 s, which flashed yellow on single missed beats.
+ */
+export const HEARTBEAT_STALE_MS = 90_000;
+
+/**
+ * Returns a freshness flag consistent with the mobile app. A device is
+ * "fresh" when it was online per Convex AND its heartbeat is within
+ * `HEARTBEAT_STALE_MS`.
+ */
+export function isDeviceFresh(d: RemoteDevice): boolean {
+  if (!d.isOnline) return false;
+  if (!d.lastHeartbeat) return true;
+  return Date.now() - d.lastHeartbeat < HEARTBEAT_STALE_MS;
+}
+
+/**
+ * Pick the best candidate for an auto-connect attempt. Preference:
+ *   1. matches the preferred deviceId when supplied + still fresh
+ *   2. fresh (online + recent heartbeat) + has a quicHost
+ *   3. online + has a quicHost
+ *   4. first with a quicHost
+ */
+export function pickTargetDevice(
+  devices: RemoteDevice[],
+  preferredDeviceId?: string,
+): RemoteDevice | null {
+  if (!devices.length) return null;
+  if (preferredDeviceId) {
+    const preferred = devices.find(
+      (d) => d.deviceId === preferredDeviceId && d.quicHost,
+    );
+    if (preferred && isDeviceFresh(preferred)) return preferred;
+    if (preferred) return preferred;
+  }
+  const fresh = devices.find((d) => isDeviceFresh(d) && d.quicHost);
+  if (fresh) return fresh;
+  const online = devices.find((d) => d.isOnline && d.quicHost);
+  if (online) return online;
+  return devices.find((d) => d.quicHost) || devices[0] || null;
+}

package/src/expo.ts

@@ -31,7 +31,6 @@ import type { FeedbackConfig } from './types';
  *
  * Defaults:
  * - trigger: 'shake'
- * - feedbackMode: 'batch'
  * - enabled: __DEV__ (only active in development)
  *
  * @param overrides - Optional partial config to override defaults
@@ -54,7 +53,6 @@ export function initExpo(overrides?: Partial<FeedbackConfig>): void {
   YaverFeedback.init({
     authToken: '', // LAN auto-discovery doesn't require a token
     trigger: 'shake',
-    feedbackMode: 'batch',
     enabled: __DEV__,
     ...overrides,
     ...(agentUrl ? { agentUrl } : {}),

package/src/index.ts

@@ -1,24 +1,29 @@
 /**
- * @yaver/feedback-react-native — Visual feedback SDK for Yaver.
+ * yaver-feedback-react-native — Visual feedback SDK for Yaver.
  *
- * Shake-to-report, screenshots, voice annotations, P2P connection,
- * device discovery, and live/narrated/batch feedback modes for vibe coding.
+ * Shake-to-report surface with five one-tap actions:
+ *  1. Hot Reload              — instant JS reload
+ *  2. Screenshot & Fix        — capture the screen under the modal and
+ *                               kick a fix task on the agent
+ *  3. Vibing                  — open a vibing session on the agent
+ *  4. Start / Stop Recording  — screen recording toggle
+ *  5. Send Video              — submit the last recording
  *
  * @example
  * ```tsx
- * import { YaverFeedback, FeedbackProvider } from '@yaver/feedback-react-native';
+ * import { YaverFeedback, FeedbackModal } from 'yaver-feedback-react-native';
  *
  * YaverFeedback.init({
  *   agentUrl: 'http://192.168.1.10:18080',
  *   authToken: 'your-token',
  *   trigger: 'shake',
- *   feedbackMode: 'live',
+ *   strictNativeAuth: true,
  * });
  *
- * // Wrap your app root:
- * <FeedbackProvider>
+ * <>
  *   <App />
- * </FeedbackProvider>
+ *   <FeedbackModal />
+ * </>
  * ```
  */
 
@@ -67,7 +72,12 @@ export type {
   RemoteDevice,
   DeviceList,
 } from './auth';
-export { captureScreenshot, startAudioRecording, stopAudioRecording } from './capture';
+export {
+  captureScreenshot,
+  startVideoRecording,
+  stopVideoRecording,
+  isVideoRecording,
+} from './capture';
 export { uploadFeedback } from './upload';
 export type {
   FeedbackConfig,
@@ -77,7 +87,6 @@ export type {
   AppInfo,
   TimelineEvent,
   FeedbackReport,
-  AgentCommentary,
   FeedbackStreamEvent,
   VoiceCapability,
   CapturedError,

package/src/types.ts

@@ -65,27 +65,6 @@ export interface FeedbackConfig {
   reportingOnly?: boolean;
   /** Max screen recording duration in seconds. Default: 120 */
   maxRecordingDuration?: number;
-  /**
-   * Feedback mode:
-   * - 'live': stream events to the agent as they happen
-   * - 'narrated': record everything, send on stop
-   * - 'batch': dump everything at end (default)
-   */
-  feedbackMode?: 'live' | 'narrated' | 'batch';
-  /**
-   * Agent commentary level (0-10).
-   * 0 = silent, 10 = agent comments on everything it sees.
-   * Only relevant in live mode. Default: 0.
-   */
-  agentCommentaryLevel?: number;
-  /**
-   * Enable voice input for feedback annotations. Always true by default.
-   * Audio is recorded on the device and sent to the agent for transcription.
-   * Works regardless of whether a speech-to-speech provider is configured —
-   * if STT is available on the agent, audio is auto-transcribed; otherwise
-   * raw audio is attached to the feedback report.
-   */
-  voiceEnabled?: boolean;
   /**
    * Maximum number of captured errors to keep in memory (ring buffer).
    * Oldest errors are evicted when the buffer is full.
@@ -180,13 +159,10 @@ export interface FeedbackConfig {
 
 export interface FeedbackBundle {
   metadata: FeedbackMetadata;
+  /** Screen-recording file path, when produced by the "Start Recording" action. */
   video?: string;
-  /** Voice annotation audio file path (WAV). Always available when voiceEnabled. */
-  audio?: string;
-  /** Transcribed text from voice annotation (if STT/S2S provider is available on agent). */
-  audioTranscript?: string;
   screenshots: string[];
-  /** Captured errors with stack traces, attached automatically when captureErrors is enabled. */
+  /** Captured errors with stack traces, attached via attachError / wrapErrorHandler. */
   errors?: CapturedError[];
 }
 
@@ -239,13 +215,6 @@ export interface FeedbackReport {
   error?: string;
 }
 
-export interface AgentCommentary {
-  id: string;
-  timestamp: string;
-  message: string;
-  type: 'observation' | 'suggestion' | 'question' | 'action';
-}
-
 export interface FeedbackStreamEvent {
   type: string;
   timestamp: string;

package/src/upload.ts

@@ -7,16 +7,17 @@ import { FeedbackBundle } from './types';
  * The agent receives the bundle at POST /feedback with:
  * - `metadata` (JSON string)
  * - `screenshot_0`, `screenshot_1`, ... (image files)
- * - `audio` (audio file, if present)
  * - `video` (video file, if present)
  *
- * @returns The feedback report ID from the agent response.
+ * Returns the parsed agent response — typically `{ ok, id, reportId }`.
+ * Callers can inspect `.id` / `.reportId` to drive a follow-up
+ * `/feedback/{id}/fix` kick.
  */
 export async function uploadFeedback(
   agentUrl: string,
   authToken: string,
   bundle: FeedbackBundle,
-): Promise<string> {
+): Promise<{ id?: string; reportId?: string; [k: string]: unknown }> {
   const formData = new FormData();
 
   // Attach metadata as JSON
@@ -32,16 +33,6 @@ export async function uploadFeedback(
     } as any);
   }
 
-  // Attach audio
-  if (bundle.audio) {
-    formData.append('audio', {
-      uri:
-        Platform.OS === 'android' ? `file://${bundle.audio}` : bundle.audio,
-      type: 'audio/m4a',
-      name: 'voice_note.m4a',
-    } as any);
-  }
-
   // Attach video
   if (bundle.video) {
     formData.append('video', {
@@ -69,6 +60,6 @@ export async function uploadFeedback(
     );
   }
 
-  const result = await response.json();
-  return result.id ?? result.reportId ?? 'unknown';
+  const result = await response.json().catch(() => ({}));
+  return result as { id?: string; reportId?: string; [k: string]: unknown };
 }