yaver-feedback-react-native 0.9.7 → 0.9.9

package/src/__tests__/YaverFeedback.test.ts

@@ -1,5 +1,6 @@
 import { DeviceEventEmitter, NativeModules } from 'react-native';
 import { YaverFeedback } from '../YaverFeedback';
+import { getDogfoodAccountAccess, setDogfoodControlPreference } from '../auth';
 
 // Mock react-native: DeviceEventEmitter for event dispatch + Platform so
 // ShakeDetector.start() can branch on iOS without hitting a real RN runtime.
@@ -14,6 +15,10 @@ jest.mock('react-native', () => ({
       setDogfoodShortcut: jest.fn(async () => true),
       consumeDogfoodShortcut: jest.fn(async () => false),
     },
+    YaverDogfoodGesture: {
+      getCapability: jest.fn(async () => ({ supported: true, enabled: false, reason: 'supported', platform: 'ios' })),
+      setEnabled: jest.fn(async (next: boolean) => ({ supported: true, enabled: next, reason: 'supported', platform: 'ios' })),
+    },
   },
   AppState: { addEventListener: jest.fn(() => ({ remove: jest.fn() })) },
 }));
@@ -33,8 +38,10 @@ jest.mock('../auth', () => ({
   getDogfoodAccountAccess: jest.fn(async (_appId: string, token: string) => ({
     authenticated: token === 'owner-token',
     ownerAuthorized: token === 'owner-token',
+    accountAuthorized: token === 'owner-token',
     installationAuthorized: token === 'owner-token',
   })),
+  setDogfoodControlPreference: jest.fn(async () => true),
   saveSelectedDeviceId: jest.fn(async () => {}),
   clearToken: jest.fn(async () => {}),
   clearSelectedDeviceId: jest.fn(async () => {}),
@@ -65,6 +72,27 @@ beforeEach(() => {
   jest.clearAllMocks();
 });
 
+function activeDogfood(controlGesture: true | { durationMs: number } = true) {
+  return {
+    enabled: true,
+    appId: 'io.example.app',
+    installationId: 'phone-1',
+    installationStatus: 'active' as const,
+    controlGesture,
+  };
+}
+
+function initActiveDogfood(options: { authToken?: string; controlGesture?: true | { durationMs: number } } = {}) {
+  const controlGesture = options.controlGesture ?? true;
+  YaverFeedback.init({
+    authToken: options.authToken,
+    bundleId: 'io.example.app',
+    dogfood: { controlGesture },
+  });
+  Object.assign(YaverFeedback.getConfig()!.dogfood!, activeDogfood(controlGesture));
+  jest.clearAllMocks();
+}
+
 describe('YaverFeedback', () => {
   describe('Dogfood onboarding', () => {
     it('starts with Yaver OAuth when the host has no session', async () => {
@@ -103,6 +131,18 @@ describe('YaverFeedback', () => {
       expect(states[states.length - 1]).toBe('auth-required');
     });
 
+    it('returns a visible structured error when access verification fails', async () => {
+      YaverFeedback.init({ enabled: true, authToken: 'owner-token' });
+      (getDogfoodAccountAccess as jest.Mock).mockRejectedValueOnce(new Error('Access service unavailable'));
+      const state = await YaverFeedback.beginDogfoodOnboarding({ appId: 'io.example.app' });
+      expect(state).toEqual({
+        phase: 'error',
+        appId: 'io.example.app',
+        error: 'Access service unavailable',
+      });
+      expect(DeviceEventEmitter.emit).not.toHaveBeenCalledWith('yaverFeedback:startReport');
+    });
+
     it('lets a host ACL hide its affordance without opening auth UI', async () => {
       YaverFeedback.init({
         enabled: true,
@@ -121,6 +161,7 @@ describe('YaverFeedback', () => {
         appId: 'io.example.app',
         yaverAuthenticated: true,
         ownerAuthorized: false,
+        accountAuthorized: true,
         installationId: 'phone-1',
         deviceState: 'active',
         authorized: true,
@@ -137,6 +178,7 @@ describe('YaverFeedback', () => {
         appId: 'io.example.app',
         yaverAuthenticated: false,
         ownerAuthorized: false,
+        accountAuthorized: true,
         installationId: 'phone-1',
         deviceState: 'active',
         authorized: false,
@@ -155,6 +197,7 @@ describe('YaverFeedback', () => {
         appId: 'io.example.app',
         yaverAuthenticated: true,
         ownerAuthorized: false,
+        accountAuthorized: true,
         installationId: 'phone-1',
         deviceState: 'active',
         authorized: true,
@@ -163,6 +206,146 @@ describe('YaverFeedback', () => {
       expect((NativeModules as any).YaverHotReload.setDogfoodShortcut)
         .toHaveBeenCalledWith(false, 'Dogfood');
     });
+
+    it('keeps the Y visible until the authorized phone has completed onboarding', async () => {
+      initActiveDogfood();
+      jest.spyOn(YaverFeedback, 'getDogfoodAccess').mockResolvedValueOnce({
+        appId: 'io.example.app',
+        yaverAuthenticated: true,
+        ownerAuthorized: false,
+        accountAuthorized: true,
+        installationId: 'phone-1',
+        deviceState: 'active',
+        authorized: true,
+      });
+      const state = await YaverFeedback.syncDogfoodControlGesture();
+      expect(state).toMatchObject({
+        onboardingSeen: false,
+        presentation: 'minimized-y',
+        gestureSupported: true,
+        gestureEnabled: false,
+        fallbackVisible: true,
+      });
+      expect((NativeModules as any).YaverDogfoodGesture.setEnabled).toHaveBeenCalledWith(false, 900);
+    });
+
+    it('uses the invisible three-finger hold only after onboarding selects it', async () => {
+      initActiveDogfood();
+      jest.spyOn(YaverFeedback, 'getDogfoodAccess').mockResolvedValueOnce({
+        appId: 'io.example.app',
+        yaverAuthenticated: true,
+        ownerAuthorized: false,
+        accountAuthorized: true,
+        installationId: 'phone-1',
+        deviceState: 'active',
+        authorized: true,
+        controlPresentation: 'auto',
+        controlOnboardingSeen: true,
+      });
+      const state = await YaverFeedback.syncDogfoodControlGesture();
+      expect(state).toMatchObject({
+        onboardingSeen: true,
+        presentation: 'auto',
+        gestureSupported: true,
+        gestureEnabled: true,
+        fallbackVisible: false,
+      });
+      expect((NativeModules as any).YaverDogfoodGesture.setEnabled).toHaveBeenCalledWith(true, 900);
+    });
+
+    it('keeps the Y when native capability reports support but enabling the gesture fails', async () => {
+      initActiveDogfood();
+      jest.spyOn(YaverFeedback, 'getDogfoodAccess').mockResolvedValueOnce({
+        appId: 'io.example.app',
+        yaverAuthenticated: true,
+        ownerAuthorized: false,
+        accountAuthorized: true,
+        installationId: 'phone-1',
+        deviceState: 'active',
+        authorized: true,
+        controlPresentation: 'auto',
+        controlOnboardingSeen: true,
+      });
+      (NativeModules as any).YaverDogfoodGesture.setEnabled.mockResolvedValueOnce({
+        supported: true,
+        enabled: false,
+        reason: 'supported',
+        platform: 'ios',
+      });
+      const state = await YaverFeedback.syncDogfoodControlGesture();
+      expect(state).toMatchObject({
+        gestureSupported: true,
+        gestureEnabled: false,
+        fallbackVisible: true,
+        reason: 'gesture-enable-failed',
+      });
+    });
+
+    it('persists first-run completion for the exact account app installation', async () => {
+      initActiveDogfood({ authToken: 'owner-token' });
+      jest.spyOn(YaverFeedback, 'getDogfoodAccess').mockResolvedValueOnce({
+        appId: 'io.example.app',
+        yaverAuthenticated: true,
+        ownerAuthorized: true,
+        accountAuthorized: true,
+        installationId: 'phone-1',
+        deviceState: 'active',
+        authorized: true,
+        controlOnboardingSeen: false,
+      });
+      const state = await YaverFeedback.setDogfoodControlPresentation('minimized-y');
+      expect(state).toMatchObject({ onboardingSeen: true, presentation: 'minimized-y', fallbackVisible: true });
+      expect(setDogfoodControlPreference).toHaveBeenCalledWith(expect.objectContaining({
+        appId: 'io.example.app',
+        installationId: 'phone-1',
+        token: 'owner-token',
+        presentation: 'minimized-y',
+        controlOnboardingSeen: true,
+      }));
+    });
+
+    it('falls back to the minimized Y when accessibility owns multi-touch', async () => {
+      initActiveDogfood({ controlGesture: { durationMs: 1200 } });
+      jest.spyOn(YaverFeedback, 'getDogfoodAccess').mockResolvedValueOnce({
+        appId: 'io.example.app',
+        yaverAuthenticated: true,
+        ownerAuthorized: false,
+        accountAuthorized: true,
+        installationId: 'phone-1',
+        deviceState: 'active',
+        authorized: true,
+      });
+      (NativeModules as any).YaverDogfoodGesture.getCapability.mockResolvedValueOnce({
+        supported: false,
+        enabled: false,
+        reason: 'accessibility-touch-exploration',
+        platform: 'ios',
+      });
+      const state = await YaverFeedback.syncDogfoodControlGesture();
+      expect(state).toMatchObject({ gestureSupported: false, gestureEnabled: false, fallbackVisible: true });
+      expect((NativeModules as any).YaverDogfoodGesture.setEnabled).toHaveBeenCalledWith(false, 1200);
+    });
+
+    it('suppresses guest controls inside the Yaver split-view container', async () => {
+      initActiveDogfood();
+      (NativeModules as any).YaverInfo = { isYaver: true };
+      const state = await YaverFeedback.syncDogfoodControlGesture();
+      delete (NativeModules as any).YaverInfo;
+      expect(state).toMatchObject({ gestureEnabled: false, fallbackVisible: false, reason: 'yaver-host-owns-controls' });
+    });
+
+    it('removes the gesture and fallback Y when Dogfood exits', async () => {
+      initActiveDogfood();
+      await YaverFeedback.exitDogfoodMode();
+      const state = await YaverFeedback.syncDogfoodControlGesture();
+      expect(state).toMatchObject({
+        authorized: false,
+        gestureEnabled: false,
+        fallbackVisible: false,
+        reason: 'dogfood-session-inactive',
+      });
+      expect((NativeModules as any).YaverDogfoodGesture.setEnabled).toHaveBeenCalledWith(false, 900);
+    });
   });
 
   describe('init()', () => {

package/src/auth.ts

@@ -207,7 +207,12 @@ export async function clearSelectedDeviceId(): Promise<void> {
 export async function getDogfoodAccountAccess(appId: string, token: string, installationId?: string): Promise<{
   authenticated: boolean;
   ownerAuthorized: boolean;
+  accountAuthorized: boolean;
   installationAuthorized: boolean;
+  controlPresentation?: 'auto' | 'minimized-y';
+  gestureSupported?: boolean;
+  gestureCapabilityReason?: string;
+  controlOnboardingSeen?: boolean;
 }> {
   try {
     const controller = new AbortController();
@@ -219,15 +224,61 @@ export async function getDogfoodAccountAccess(appId: string, token: string, inst
       signal: controller.signal,
     });
     clearTimeout(timeout);
-    if (!response.ok) return { authenticated: false, ownerAuthorized: false, installationAuthorized: false };
+    if (!response.ok) return { authenticated: false, ownerAuthorized: false, accountAuthorized: false, installationAuthorized: false };
     const result = await response.json();
     return {
       authenticated: result?.authenticated === true,
       ownerAuthorized: result?.ownerAuthorized === true,
+      accountAuthorized: result?.accountAuthorized === true,
       installationAuthorized: result?.installationAuthorized === true,
+      controlPresentation: result?.controlPresentation === 'minimized-y' ? 'minimized-y'
+        : result?.controlPresentation === 'auto' ? 'auto' : undefined,
+      gestureSupported: typeof result?.gestureSupported === 'boolean' ? result.gestureSupported : undefined,
+      gestureCapabilityReason: typeof result?.gestureCapabilityReason === 'string'
+        ? result.gestureCapabilityReason
+        : undefined,
+      controlOnboardingSeen: result?.controlOnboardingSeen === true,
     };
   } catch {
-    return { authenticated: false, ownerAuthorized: false, installationAuthorized: false };
+    return { authenticated: false, ownerAuthorized: false, accountAuthorized: false, installationAuthorized: false };
+  }
+}
+
+export async function setDogfoodControlPreference(input: {
+  appId: string;
+  installationId: string;
+  token: string;
+  presentation: 'auto' | 'minimized-y';
+  gestureSupported: boolean;
+  gestureCapabilityReason: string;
+  gesturePlatform: string;
+  controlOnboardingSeen?: boolean;
+}): Promise<boolean> {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), 5_000);
+  try {
+    const response = await fetch(`${convexSiteUrl}/dogfood/control-preference`, {
+      method: 'POST',
+      headers: {
+        Authorization: `Bearer ${input.token}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({
+        appId: input.appId,
+        installationId: input.installationId,
+        presentation: input.presentation,
+        gestureSupported: input.gestureSupported,
+        gestureCapabilityReason: input.gestureCapabilityReason,
+        gesturePlatform: input.gesturePlatform,
+        controlOnboardingSeen: input.controlOnboardingSeen === true,
+      }),
+      signal: controller.signal,
+    });
+    return response.ok;
+  } catch {
+    return false;
+  } finally {
+    clearTimeout(timeout);
   }
 }
 

package/src/dogfoodPolicy.ts

@@ -4,10 +4,18 @@ export interface DogfoodAccessSnapshot {
   yaverAuthenticated: boolean;
   /** Backend-confirmed owner/maintainer of this exact appId. */
   ownerAuthorized: boolean;
+  /** Backend-confirmed app assignment for this Yaver account. App owners are
+   * assigned implicitly; other accounts require an active owner grant. */
+  accountAuthorized: boolean;
   installationId?: string;
   deviceState: 'unknown' | 'unregistered' | 'pending' | 'active' | 'cancelled' | 'revoked' | 'superseded';
-  /** True only for a backend-approved device key or an authenticated owner. */
+  /** True only for an assigned account and this backend-approved device key. */
   authorized: boolean;
+  /** OAuth-backed preference scoped to this user + app + installation. */
+  controlPresentation?: 'auto' | 'minimized-y';
+  gestureSupported?: boolean;
+  gestureCapabilityReason?: string;
+  controlOnboardingSeen?: boolean;
 }
 
 export interface DogfoodFlowSnapshot {
@@ -44,6 +52,19 @@ export interface SDKDogfoodConfig {
   /** ACL-backed Home Screen/App Shortcut. Dynamic and absent until Yaver
    * owner auth or this installation's approved key authorizes it. */
   appShortcut?: boolean | { label?: string };
+  /** Smart in-app quick controls. On supported standalone iOS/Android builds,
+   * a three-finger hold opens a two-action card with no persistent overlay.
+   * Unsupported/accessibility-conflicted devices may show a minimized,
+   * draggable Y fallback. Yaver host/container mode suppresses both. */
+  controlGesture?: boolean | {
+    /** Hold duration, clamped to 650–2000 ms. Default 900 ms. */
+    durationMs?: number;
+    /** Default `minimized-y`; use `none` when Settings is the only fallback. */
+    fallback?: 'minimized-y' | 'none';
+    /** Initial user-facing presentation before their persisted SDK preference
+     * exists. `auto` keeps pixels clear when the gesture works. */
+    defaultPresentation?: 'auto' | 'minimized-y';
+  };
 }
 
 export interface SDKDogfoodStatus {

package/src/index.ts

@@ -29,7 +29,12 @@
  */
 
 export { YaverFeedback } from './YaverFeedback';
-export type { DogfoodOnboardingOptions, DogfoodFlowPhase, DogfoodFlowState } from './YaverFeedback';
+export type {
+  DogfoodOnboardingOptions,
+  DogfoodFlowPhase,
+  DogfoodFlowState,
+  DogfoodControlTriggerState,
+} from './YaverFeedback';
 export { captureStoreScreenshots } from './storeShots';
 export type {
   CaptureStoreScreenshotsOptions,
@@ -106,7 +111,14 @@ export type {
   DogfoodRunContext,
   DogfoodSnapshot,
 } from './DogfoodRuntime';
+export { DogfoodLanePicker, DogfoodLiveConsole, DogfoodStatusRail } from './DogfoodSessionUi';
+export type {
+  DogfoodStatusStep,
+  DogfoodStatusTone,
+  DogfoodUiColors,
+} from './DogfoodSessionUi';
 export { FeedbackModal } from './FeedbackModal';
+export { DogfoodQuickControls } from './DogfoodQuickControls';
 export { QuickActionIcon } from './QuickActionIcon';
 export type { QuickActionIconProps } from './QuickActionIcon';
 export { FixReport } from './FixReport';

package/src/preferences.ts

@@ -26,6 +26,95 @@ try {
 
 const QUICK_ICON_DISABLED_KEY = 'yaver_feedback_quickicon_disabled';
 const QUICK_ICON_COLOR_KEY = 'yaver_feedback_quickicon_color';
+const DOGFOOD_CONTROL_PRESENTATION_KEY = 'yaver_dogfood_control_presentation';
+const DOGFOOD_CONTROL_POSITION_PREFIX = 'yaver_dogfood_control_position_';
+const DOGFOOD_CONTROL_ONBOARDING_PREFIX = 'yaver_dogfood_control_onboarding_';
+
+export type DogfoodControlPresentation = 'auto' | 'minimized-y';
+export type DogfoodControlEdge = 'left' | 'right';
+export interface DogfoodControlPosition {
+  edge: DogfoodControlEdge;
+  /** 0–1 within the safe vertical travel area. */
+  yRatio: number;
+}
+
+function dogfoodPreferenceKey(base: string, scope?: string): string {
+  const normalized = String(scope || 'legacy').trim() || 'legacy';
+  return `${base}_${encodeURIComponent(normalized)}`;
+}
+
+export async function getDogfoodControlPresentation(scope?: string): Promise<DogfoodControlPresentation | null> {
+  if (!AsyncStorage) return null;
+  try {
+    const value = await AsyncStorage.getItem(dogfoodPreferenceKey(DOGFOOD_CONTROL_PRESENTATION_KEY, scope));
+    return value === 'auto' || value === 'minimized-y' ? value : null;
+  } catch {
+    return null;
+  }
+}
+
+export async function setDogfoodControlPresentation(value: DogfoodControlPresentation, scope?: string): Promise<void> {
+  if (!AsyncStorage) return;
+  try {
+    await AsyncStorage.setItem(dogfoodPreferenceKey(DOGFOOD_CONTROL_PRESENTATION_KEY, scope), value);
+  } catch {
+    // best-effort
+  }
+}
+
+export async function getDogfoodControlPosition(
+  orientation: 'portrait' | 'landscape',
+  scope?: string,
+): Promise<DogfoodControlPosition | null> {
+  if (!AsyncStorage) return null;
+  try {
+    const raw = await AsyncStorage.getItem(
+      dogfoodPreferenceKey(`${DOGFOOD_CONTROL_POSITION_PREFIX}${orientation}`, scope),
+    );
+    if (!raw) return null;
+    const parsed = JSON.parse(raw) as Partial<DogfoodControlPosition>;
+    if ((parsed.edge !== 'left' && parsed.edge !== 'right') || typeof parsed.yRatio !== 'number') return null;
+    return { edge: parsed.edge, yRatio: Math.max(0, Math.min(1, parsed.yRatio)) };
+  } catch {
+    return null;
+  }
+}
+
+export async function setDogfoodControlPosition(
+  orientation: 'portrait' | 'landscape',
+  position: DogfoodControlPosition,
+  scope?: string,
+): Promise<void> {
+  if (!AsyncStorage) return;
+  try {
+    await AsyncStorage.setItem(
+      dogfoodPreferenceKey(`${DOGFOOD_CONTROL_POSITION_PREFIX}${orientation}`, scope),
+      JSON.stringify(position),
+    );
+  } catch {
+    // best-effort
+  }
+}
+
+export async function getDogfoodControlOnboardingSeen(scope?: string): Promise<boolean> {
+  if (!AsyncStorage) return false;
+  try {
+    return await AsyncStorage.getItem(dogfoodPreferenceKey(DOGFOOD_CONTROL_ONBOARDING_PREFIX, scope)) === '1';
+  } catch {
+    return false;
+  }
+}
+
+export async function setDogfoodControlOnboardingSeen(seen: boolean, scope?: string): Promise<void> {
+  if (!AsyncStorage) return;
+  try {
+    const key = dogfoodPreferenceKey(DOGFOOD_CONTROL_ONBOARDING_PREFIX, scope);
+    if (seen) await AsyncStorage.setItem(key, '1');
+    else await AsyncStorage.removeItem(key);
+  } catch {
+    // best-effort startup cache; Convex remains authoritative.
+  }
+}
 
 export type QuickIconColorPreset =
   | 'orange'