yaver-feedback-react-native 0.9.2 → 0.9.3

package/src/YaverFeedback.ts

@@ -15,7 +15,6 @@ import {
   getToken,
   getSelectedDeviceId,
   listReachableDevices,
-  mintGuestSdkToken,
   clearToken,
   clearSelectedDeviceId,
   DEFAULT_CONVEX_SITE_URL,
@@ -27,6 +26,15 @@ import {
   setQuickIconColorPreset,
   QuickIconColorPreset,
 } from './preferences';
+import { resolveSDKDogfood, type SDKDogfoodStatus } from './dogfoodPolicy';
+import { YaverDeviceDogfood, type DeviceDogfoodOptions, type DeviceDogfoodSession, type DeviceDogfoodState } from './deviceDogfood';
+
+export interface DogfoodOnboardingOptions extends DeviceDogfoodOptions {
+  /** Hint used to preselect the matching project returned by the owner machine. */
+  projectName?: string;
+  /** Framework fallback when the machine has not classified the project yet. */
+  framework?: string;
+}
 
 function unrefTimer(timer: ReturnType<typeof setTimeout>): void {
   const maybeNodeTimer = timer as unknown as { unref?: () => void };
@@ -158,6 +166,7 @@ if (IS_HOST_MODE) {
 let config: FeedbackConfig | null = null;
 let enabled = false;
 let p2pClient: P2PClient | null = null;
+let renderP2PClient: P2PClient | null = null;
 let shakeDetector: ShakeDetector | null = null;
 /** Unsubscribe for the BlackBox command handler registered by init(). Held so
  *  a re-init (or destroy) can drop the old one instead of stacking. */
@@ -169,6 +178,7 @@ let p2pRelayPassword: string = '';
 let autoStartTimer: ReturnType<typeof setTimeout> | null = null;
 let reportLaunchInFlight = false;
 let crashReportInFlight = false;
+let dogfoodOnboarding: DogfoodOnboardingOptions | null = null;
 
 /** Resolve the user's relay password by validating their auth token
  *  against Convex. Used whenever we (re)build the P2PClient so a
@@ -241,42 +251,35 @@ const flagCache: Map<string, { value: unknown; at: number }> = new Map();
  */
 export class YaverFeedback {
   private static async resolveP2PAuthToken(): Promise<string | null> {
-    if (!config?.authToken) return null;
-    if (!config.preferredDeviceId) return config.authToken;
-    const devices = await listReachableDevices(config.authToken);
-    const all = [...devices.owned, ...devices.shared];
-    const selected = all.find((device) => device.deviceId === config?.preferredDeviceId);
-    if (!selected || !selected.isGuest || selected.accessScope !== 'shared-scoped') {
-      return config.authToken;
-    }
-    if (!selected.hostUserId) {
-      return config.authToken;
-    }
-    const delegated = await mintGuestSdkToken(
-      config.authToken,
-      selected.hostUserId,
-      selected.deviceId,
-    );
-    return delegated.token;
+    return config?.authToken ?? null;
   }
 
   private static async rebuildP2PClient(agentUrl?: string): Promise<void> {
-    if (!config) return;
-    const effectiveUrl = agentUrl ?? config.agentUrl;
+    const currentConfig = config;
+    if (!currentConfig) return;
+    const effectiveUrl = agentUrl ?? currentConfig.agentUrl;
     if (!effectiveUrl) {
       p2pClient = null;
+      renderP2PClient = null;
       p2pAuthToken = null;
       return;
     }
     const token = await YaverFeedback.resolveP2PAuthToken();
+    // reset() can clear config while relay-password resolution is awaiting.
+    // Do not resurrect a client from that stale init generation.
+    if (config !== currentConfig) return;
     if (!token) {
       p2pClient = null;
+      renderP2PClient = null;
       p2pAuthToken = null;
       return;
     }
     p2pAuthToken = token;
     const rp = await resolveRelayPassword(token);
+    if (config !== currentConfig) return;
     p2pClient = new P2PClient(effectiveUrl, token, rp);
+    const renderUrl = currentConfig.renderAgentUrl || effectiveUrl;
+    renderP2PClient = renderUrl === effectiveUrl ? p2pClient : new P2PClient(renderUrl, token, rp);
   }
 
   /**
@@ -365,6 +368,9 @@ export class YaverFeedback {
       maxRecordingDuration: 120,
       autoLogin: true,
       ...cfg,
+      agentUrl: cfg.codingAgentUrl || cfg.agentUrl,
+      codingDeviceId: cfg.codingDeviceId || cfg.preferredDeviceId,
+      renderDeviceId: cfg.renderDeviceId || cfg.codingDeviceId || cfg.preferredDeviceId,
     };
     if (IS_HOST_MODE) {
       // sfmg / talos / etc. running inside Yaver mobile (compile-time
@@ -441,11 +447,16 @@ export class YaverFeedback {
       // is set, so set a placeholder header here that won't 401 a
       // direct-LAN url and will be overwritten before any relay hop.
       p2pClient = new P2PClient(config.agentUrl, config.authToken ?? '', p2pRelayPassword);
+      const renderUrl = config.renderAgentUrl || config.agentUrl;
+      renderP2PClient = renderUrl === config.agentUrl
+        ? p2pClient
+        : new P2PClient(renderUrl, config.authToken ?? '', p2pRelayPassword);
       if (config.authToken) {
         void YaverFeedback.rebuildP2PClient(config.agentUrl);
       }
     } else {
       p2pClient = null;
+      renderP2PClient = null;
       // Auto-discover agent in the background when convexUrl or LAN is available
       if (enabled && (config.authToken || config.preferredDeviceId)) {
         YaverFeedback.discoverAgent();
@@ -796,6 +807,27 @@ export class YaverFeedback {
     DeviceEventEmitter.emit('yaverFeedback:startMachinePicker');
   }
 
+  /** Begin the reusable host-app Dogfood wizard. Owner OAuth and machine
+   * selection intentionally happen before installation enrollment/runtime
+   * controls because starting builds or runners is owner-level authority. */
+  static beginDogfoodOnboarding(options: DogfoodOnboardingOptions): void {
+    dogfoodOnboarding = options;
+    if (!config) YaverFeedback.init({ autoLogin: true } as FeedbackConfig);
+    if (!YaverFeedback.isAuthed()) {
+      YaverFeedback.showLogin();
+      return;
+    }
+    YaverFeedback.showMachinePicker();
+  }
+
+  static getDogfoodOnboarding(): DogfoodOnboardingOptions | null {
+    return dogfoodOnboarding;
+  }
+
+  static clearDogfoodOnboarding(): void {
+    dogfoodOnboarding = null;
+  }
+
   /**
    * Update the selected remote device. Resets the cached agent URL so the
    * next `startReport()` (or FloatingButton press) rediscovers against the
@@ -803,9 +835,17 @@ export class YaverFeedback {
    */
   static async setPreferredDevice(deviceId: string): Promise<void> {
     if (!config) return;
+    const wasUnified = !config.renderDeviceId
+      || config.renderDeviceId === config.codingDeviceId
+      || config.renderDeviceId === config.preferredDeviceId;
     config.preferredDeviceId = deviceId;
+    config.codingDeviceId = deviceId;
+    if (wasUnified) config.renderDeviceId = deviceId;
     config.agentUrl = undefined;
+    config.codingAgentUrl = undefined;
+    if (wasUnified) config.renderAgentUrl = undefined;
     p2pClient = null;
+    renderP2PClient = null;
     p2pAuthToken = null;
     await YaverFeedback.discoverAgent();
   }
@@ -815,8 +855,7 @@ export class YaverFeedback {
     if (!config?.authToken || !config.preferredDeviceId) return null;
     const preferredDeviceId = config.preferredDeviceId;
     const devices = await listReachableDevices(config.authToken);
-    const all = [...devices.owned, ...devices.shared];
-    return all.find((device) => device.deviceId === preferredDeviceId) ?? null;
+    return devices.owned.find((device) => device.deviceId === preferredDeviceId) ?? null;
   }
 
   /**
@@ -876,6 +915,7 @@ export class YaverFeedback {
       config.agentUrl = undefined;
     }
     p2pClient = null;
+    renderP2PClient = null;
     p2pAuthToken = null;
   }
 
@@ -1133,6 +1173,63 @@ export class YaverFeedback {
     return config;
   }
 
+  /** Current third-party SDK mode. Fails closed unless enabled + account match. */
+  static getDogfoodStatus(): SDKDogfoodStatus {
+    return resolveSDKDogfood(config?.dogfood);
+  }
+
+  /** One-call, account-free Dogfood bootstrap for third-party apps. On first
+   * launch it creates/proves the installation key and returns pending; after
+   * owner approval the same call obtains a short-lived scoped Yaver session
+   * and enables Dogfood UX without the host app implementing OAuth. */
+  static async enableDeviceDogfood(options: DeviceDogfoodOptions): Promise<{
+    status: DeviceDogfoodState;
+    installationId: string;
+    session: DeviceDogfoodSession | null;
+  }> {
+    const client = new YaverDeviceDogfood(options);
+    let status = await client.status();
+    if (status === 'unregistered' || status === 'pending' || status === 'cancelled' || status === 'revoked' || status === 'superseded') {
+      const enrolled = status === 'unregistered' || status === 'pending'
+        ? await client.enroll(Platform.OS)
+        : await client.reRegister(Platform.OS);
+      status = enrolled.status;
+    }
+    const info = await client.enrollmentInfo();
+    const session = status === 'active' ? await client.session() : null;
+    if (!config) YaverFeedback.init({ autoLogin: false } as FeedbackConfig);
+    if (config) {
+      config.dogfood = {
+        enabled: status === 'active' && !!session,
+        appId: options.appId,
+        installationId: info.installationId,
+        installationStatus: status === 'active' && session ? 'active' : status === 'unregistered' ? 'pending' : status,
+        label: options.label,
+      };
+      // A normal Yaver OAuth session remains authoritative for the runtime
+      // wizard. Only account-free hosts adopt the narrow installation token.
+      if (session && !config.authToken) await YaverFeedback.setAuthToken(session.token);
+    }
+    try {
+      const { DeviceEventEmitter } = require('react-native');
+      DeviceEventEmitter.emit('yaverFeedback:dogfoodChanged', { active: !!session, status });
+    } catch { /* noop */ }
+    return { status, installationId: info.installationId, session };
+  }
+
+  /** Confirmed by the Y badge/UI before this is called. Reverts this SDK to
+   * normal Feedback mode for the remainder of the app run. */
+  static async exitDogfoodMode(): Promise<void> {
+    const cfg = config?.dogfood;
+    if (!cfg) return;
+    cfg.enabled = false;
+    await cfg.onExit?.();
+    try {
+      const { DeviceEventEmitter } = require('react-native');
+      DeviceEventEmitter.emit('yaverFeedback:dogfoodChanged', { active: false, exited: true });
+    } catch { /* noop */ }
+  }
+
   /** Returns the resolved relay password the SDK is currently using.
    *  Empty string when no relay routing is in play (direct LAN agent
    *  URLs need no password). Callers attaching it to relay-routed
@@ -1316,6 +1413,18 @@ export class YaverFeedback {
     return p2pClient;
   }
 
+  /** Renderer/reload route; intentionally distinct from the coding client. */
+  static getRenderP2PClient(): P2PClient | null {
+    return renderP2PClient ?? p2pClient;
+  }
+
+  static getMachineRouting(): { codingDeviceId?: string; renderDeviceId?: string } {
+    return {
+      codingDeviceId: config?.codingDeviceId || config?.preferredDeviceId,
+      renderDeviceId: config?.renderDeviceId || config?.codingDeviceId || config?.preferredDeviceId,
+    };
+  }
+
   // ─── One-stop SaaS replacement methods ─────────────────────────
   //
   // These are the three solo-dev SaaS-replacement entry points
@@ -1435,6 +1544,7 @@ export class YaverFeedback {
           config.agentUrl = result.url;
           const rp = await resolveRelayPassword(config.authToken ?? '');
           p2pClient = new P2PClient(result.url, config.authToken ?? '', rp);
+          renderP2PClient = p2pClient;
         }
       } catch {}
     }
@@ -1667,6 +1777,7 @@ export class YaverFeedback {
     enabled = false;
     config = null;
     p2pClient = null;
+    renderP2PClient = null;
     errorBuffer = [];
   }
 }

package/src/YaverModeBadge.tsx

@@ -0,0 +1,234 @@
+// YaverModeBadge.tsx — the polite "you're running inside Yaver" mark, for
+// THIRD-PARTY apps.
+//
+// ── Why a third-party app needs this ────────────────────────────────────────
+//
+// When your app is pushed into Yaver's container as a Hermes bundle, it looks
+// exactly like your installed build. Same icon, same launch, same everything —
+// except it is a development bundle from someone's branch. Testers have chased
+// "bugs" that were only unbuilt work, and have been unable to find their way
+// back to the real app because nothing on screen said there was anywhere to go.
+//
+// So the SDK shows one small Y, low contrast, in a corner. Tapping it says what
+// you're in and how to leave. Nothing else.
+//
+// ── Defaults, and why ───────────────────────────────────────────────────────
+//
+// DEFAULT ENABLED (`modeBadge: true`), because the failure it prevents is
+// silent and lands on a tester rather than the developer — exactly the class
+// that should not be opt-in. Turn it off with `modeBadge: false` when your app
+// has its own in-container indicator, or when a screenshot-perfect surface
+// genuinely cannot afford 22 points in a corner.
+//
+// ── What it is NOT ──────────────────────────────────────────────────────────
+//
+// It is NOT the escape. Yaver's container owns that: shake opens Yaver's own
+// overlay with "Back to Yaver". This badge only tells you the gesture exists.
+// Making it the exit would put the way out inside the previewed app, which is
+// the trap the container's escape-ownership rules exist to prevent — the guest
+// could style over it, or unmount it, and the tester would be stuck.
+
+import React, { useEffect, useState } from 'react';
+import { Alert, Modal, NativeModules, Pressable, Text, View } from 'react-native';
+
+/** True only inside Yaver's container: the YaverInfo native module is
+ *  registered by Yaver's app and by nothing else. Same probe ShakeDetector
+ *  and P2PClient use — one answer, not three. */
+function isInsideYaver(): boolean {
+  try {
+    return !!(NativeModules as any)?.YaverInfo;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Per-RUN dismissal, shared by every mounted badge.
+ *
+ * Deliberately in memory, not storage. A permanently hidden badge recreates
+ * exactly the problem the badge exists to prevent: a tester who cannot tell an
+ * unbuilt branch from the installed app, and cannot find the way back. Polite
+ * means not nagging within a session — it does not mean permanent amnesia
+ * about which build you are looking at. A relaunch is a new context.
+ *
+ * An APP that wants it gone for good passes `modeBadge: false` at init. That is
+ * a developer making an informed choice, which is a different thing from a
+ * tester clearing their screen for a minute.
+ */
+let hiddenThisRun = false;
+const hideListeners = new Set<() => void>();
+
+/** Hide the mark for the rest of this run. Exposed on YaverFeedback so a host
+ *  can wire its own "hide" control, and used by the sheet's own button. */
+export function hideYaverModeBadge(): void {
+  hiddenThisRun = true;
+  hideListeners.forEach((l) => {
+    try {
+      l();
+    } catch {
+      /* one bad listener mustn't block the others */
+    }
+  });
+}
+
+/** Bring it back — e.g. when a NEW guest bundle loads and the context changed. */
+export function showYaverModeBadge(): void {
+  hiddenThisRun = false;
+  hideListeners.forEach((l) => {
+    try {
+      l();
+    } catch {
+      /* noop */
+    }
+  });
+}
+
+export function isYaverModeBadgeHidden(): boolean {
+  return hiddenThisRun;
+}
+
+export interface YaverModeBadgeProps {
+  /** Corner to sit in. Default bottom-left: bottom-right is where most apps
+   *  put a FAB, and the badge must never compete with the app's own action. */
+  position?: 'bottom-left' | 'bottom-right' | 'top-left' | 'top-right';
+  /** Render even outside Yaver. Development aid only — the badge is meaningless
+   *  in a standalone build and would be wallpaper. */
+  force?: boolean;
+  /** Account-scoped third-party Dogfood mode. Keeps the same Yaver Y mark but
+   * changes the explanation and offers a confirmed exit to normal Feedback. */
+  dogfood?: boolean;
+  dogfoodLabel?: string;
+  onExitDogfood?: () => void | Promise<void>;
+}
+
+export function YaverModeBadge({
+  position = 'bottom-left',
+  force = false,
+  dogfood = false,
+  dogfoodLabel = 'Dogfood',
+  onExitDogfood,
+}: YaverModeBadgeProps) {
+  const [open, setOpen] = useState(false);
+  const [, bump] = useState(0);
+
+  useEffect(() => {
+    const listener = () => bump((n) => n + 1);
+    hideListeners.add(listener);
+    return () => {
+      hideListeners.delete(listener);
+    };
+  }, []);
+
+  // Standalone builds render nothing at all — zero cost, zero pixels.
+  if (!force && !dogfood && !isInsideYaver()) return null;
+  if (hiddenThisRun) return null;
+
+  const vertical = position.startsWith('top') ? { top: 44 } : { bottom: 28 };
+  const horizontal = position.endsWith('left') ? { left: 12 } : { right: 12 };
+
+  return (
+    <>
+      <View
+        // The wrapper never intercepts touches; only the 22pt mark does. A
+        // full-screen overlay that swallowed taps would break the app it is
+        // supposed to be politely annotating.
+        pointerEvents="box-none"
+        style={{ position: 'absolute', ...vertical, ...horizontal, zIndex: 9998 }}
+      >
+        <Pressable
+          onPress={() => setOpen(true)}
+          accessibilityRole="button"
+          accessibilityLabel={dogfood ? `Exit ${dogfoodLabel} Dogfood mode` : 'Running inside Yaver'}
+          hitSlop={10}
+          style={({ pressed }) => ({
+            width: 22,
+            height: 22,
+            borderRadius: 11,
+            alignItems: 'center',
+            justifyContent: 'center',
+            borderWidth: 1,
+            borderColor: 'rgba(124,92,255,0.45)',
+            backgroundColor: 'rgba(124,92,255,0.14)',
+            opacity: pressed ? 0.6 : 0.9,
+          })}
+        >
+          <Text style={{ color: '#7C5CFF', fontSize: 12, fontWeight: '700', lineHeight: 14 }}>Y</Text>
+        </Pressable>
+      </View>
+
+      <Modal visible={open} transparent animationType="fade" onRequestClose={() => setOpen(false)}>
+        <Pressable style={{ flex: 1, backgroundColor: '#0008' }} onPress={() => setOpen(false)}>
+          <Pressable
+            onPress={(e) => e.stopPropagation()}
+            style={{
+              margin: 24,
+              marginTop: 'auto',
+              marginBottom: 48,
+              borderRadius: 16,
+              padding: 18,
+              backgroundColor: '#151519',
+              borderWidth: 1,
+              borderColor: '#2a2a32',
+              gap: 10,
+            }}
+          >
+            <View style={{ flexDirection: 'row', alignItems: 'center', gap: 8 }}>
+              <Text style={{ color: '#7C5CFF', fontSize: 15, fontWeight: '800' }}>Y</Text>
+              <Text style={{ color: '#fff', fontSize: 15, fontWeight: '700' }}>
+                {dogfood ? `${dogfoodLabel} Dogfood mode` : 'Running inside Yaver'}
+              </Text>
+            </View>
+            <Text style={{ color: '#b6b6c0', fontSize: 13, lineHeight: 19 }}>
+              {dogfood
+                ? 'This approved account is improving the app directly through Yaver. Tasks and re-render actions target this app instead of creating a feedback report.'
+                : 'This is a development build loaded into Yaver — not the version installed on this device. Anything unfinished here is work in progress, not a released bug.'}
+            </Text>
+            {dogfood ? (
+              <Pressable
+                onPress={() => Alert.alert(
+                  'Exit Dogfood mode?',
+                  'Return this SDK to normal Feedback mode. Your coding tasks and source changes are untouched.',
+                  [
+                    { text: 'Keep Dogfooding', style: 'cancel' },
+                    { text: 'Exit Dogfood', style: 'destructive', onPress: () => {
+                      void onExitDogfood?.();
+                      setOpen(false);
+                    } },
+                  ],
+                )}
+                style={{ paddingVertical: 10, alignItems: 'center' }}
+              >
+                <Text style={{ color: '#fca5a5', fontSize: 13, fontWeight: '700' }}>Exit Dogfood mode</Text>
+              </Pressable>
+            ) : (
+              <Text style={{ color: '#b6b6c0', fontSize: 13, lineHeight: 19 }}>
+                Shake the device to open Yaver's overlay, where "Back to Yaver" returns you to the installed app.
+              </Text>
+            )}
+            {/* Polite means closeable. "for now", never "don't show again":
+                the badge returns next launch so nobody forgets which build
+                they're testing. */}
+            <Pressable
+              onPress={() => {
+                hideYaverModeBadge();
+                setOpen(false);
+              }}
+              style={{ paddingVertical: 10, alignItems: 'center' }}
+            >
+              <Text style={{ color: '#8a8a96', fontSize: 13 }}>Hide for now</Text>
+            </Pressable>
+            <Text style={{ color: '#6b6b76', fontSize: 11, textAlign: 'center', lineHeight: 15 }}>
+              Hidden until you next launch this build.
+            </Text>
+
+            <Pressable onPress={() => setOpen(false)} style={{ paddingVertical: 10, alignItems: 'center' }}>
+              <Text style={{ color: '#8a8a96', fontSize: 13 }}>Close</Text>
+            </Pressable>
+          </Pressable>
+        </Pressable>
+      </Modal>
+    </>
+  );
+}
+
+export default YaverModeBadge;

package/src/__tests__/AuthDevices.test.ts

@@ -9,7 +9,7 @@ describe('auth device listing', () => {
     mockFetch.mockReset();
   });
 
-  it('keeps guest-shared devices in the shared bucket', async () => {
+  it('returns the owner devices emitted by /devices/list', async () => {
     mockFetch.mockResolvedValue({
       ok: true,
       json: () =>
@@ -20,24 +20,10 @@ describe('auth device listing', () => {
               name: 'My Mac',
               platform: 'macos',
               isOnline: true,
-              isGuest: false,
               quicHost: '10.0.0.10',
               quicPort: 18080,
               lastHeartbeat: 123,
             },
-            {
-              deviceId: 'guest-1',
-              name: 'yaver-test-ephemeral',
-              platform: 'linux',
-              isOnline: true,
-              isGuest: true,
-              hostName: 'Host User',
-              hostEmail: 'host@example.com',
-              accessScope: 'shared-scoped',
-              quicHost: '198.51.100.20',
-              quicPort: 18080,
-              lastHeartbeat: 456,
-            },
           ],
         }),
     });
@@ -51,43 +37,6 @@ describe('auth device listing', () => {
       }),
     );
     expect(result.owned).toHaveLength(1);
-    expect(result.shared).toHaveLength(1);
     expect(result.owned[0].deviceId).toBe('own-1');
-    expect(result.shared[0]).toMatchObject({
-      deviceId: 'guest-1',
-      isGuest: true,
-      hostEmail: 'host@example.com',
-      accessScope: 'shared-scoped',
-    });
-  });
-
-  it('shows shared devices even when the guest owns no machines', async () => {
-    mockFetch.mockResolvedValue({
-      ok: true,
-      json: () =>
-        Promise.resolve({
-          devices: [
-            {
-              deviceId: 'guest-only',
-              name: 'yaver-test-ephemeral',
-              platform: 'linux',
-              isOnline: true,
-              isGuest: true,
-              hostName: 'Host User',
-              hostEmail: 'host@example.com',
-              accessScope: 'shared-scoped',
-              quicHost: '198.51.100.20',
-              quicPort: 18080,
-              lastHeartbeat: 789,
-            },
-          ],
-        }),
-    });
-
-    const result = await listReachableDevices('guest-only-token');
-
-    expect(result.owned).toEqual([]);
-    expect(result.shared).toHaveLength(1);
-    expect(result.shared[0].deviceId).toBe('guest-only');
   });
 });