yaver-feedback-react-native 0.9.8 → 0.9.10

package/src/FeedbackModalTheme.ts

@@ -0,0 +1,29 @@
+import type { DogfoodUiColors } from './DogfoodSessionUi';
+
+/** High-contrast colors for shared Dogfood controls inside the light SDK sheet. */
+export const FEEDBACK_DOGFOOD_LIGHT_COLORS: DogfoodUiColors = {
+  background: '#ffffff',
+  border: '#c9c9d5',
+  text: '#222229',
+  muted: '#5f5f6b',
+  accent: '#5645d8',
+  accentSoft: '#e7e5ff',
+  ready: '#137a3f',
+  attention: '#9a5700',
+  blocked: '#b42318',
+  console: '#ffffff',
+};
+
+/** The log surface stays dark, but its foregrounds are explicit and readable. */
+export const FEEDBACK_DOGFOOD_CONSOLE_COLORS: DogfoodUiColors = {
+  ...FEEDBACK_DOGFOOD_LIGHT_COLORS,
+  background: '#15151b',
+  border: '#454552',
+  text: '#f8fafc',
+  muted: '#cbd5e1',
+  accent: '#a5b4fc',
+  ready: '#4ade80',
+  attention: '#fbbf24',
+  blocked: '#fca5a5',
+  console: '#15151b',
+};

package/src/P2PClient.ts

@@ -315,7 +315,7 @@ function friendlyReloadError(status: number, body: string): string {
   if (hasRefused && hasLoopback) {
     return (
       'No dev server running on your machine. ' +
-      'Start Metro with `yaver dev start` or use "Screenshot & Fix" instead.'
+      'Start Metro with `yaver dev start`, or describe the issue in Chat so the agent can inspect it.'
     );
   }
   if (
@@ -491,6 +491,8 @@ export class P2PClient {
     framework?: string;
     frameworks?: string[];
     surfaces?: string[];
+    branch?: string;
+    gitRemote?: string;
   }>> {
     const resp = await fetch(`${this.baseUrl}/projects`, { headers: this.authHeaders() });
     if (!resp.ok) {

package/src/P2PDogfoodDriver.ts

@@ -56,8 +56,18 @@ export function createP2PDogfoodDriver(
             retryable: true,
           });
         }
+        context.log({
+          text: `[runtime] source · ${target.label}${target.platform ? ` · ${target.platform}` : ''}`,
+          at: Date.now(),
+          stream: 'system',
+        });
         context.setPhase('starting', `Starting ${target.label} over WebRTC…`);
         const session = await client.startDogfoodRemoteRuntime(project.workDir, project.framework, target.id);
+        context.log({
+          text: `[runtime] ${session.status || 'starting'}${session.note ? ` · ${session.note}` : ''}`,
+          at: Date.now(),
+          stream: 'system',
+        });
         context.registerCleanup(() => client.stopDogfoodRemoteRuntime(session.id), 'session');
         return {
           lane: 'webrtc',
@@ -67,6 +77,13 @@ export function createP2PDogfoodDriver(
       }
       context.setPhase(project.lane === 'hermes' ? 'compiling' : 'starting',
         project.lane === 'hermes' ? `Compiling ${project.name} with Hermes…` : `Starting ${project.name} in the browser…`);
+      context.log({
+        text: project.lane === 'hermes'
+          ? `[runtime] source · Hermes build on ${project.workDir}`
+          : `[runtime] source · browser build on ${project.workDir}`,
+        at: Date.now(),
+        stream: 'system',
+      });
       const status = await client.startDogfoodDevServer({
         framework: project.framework,
         workDir: project.workDir,

package/src/YaverFeedback.ts

@@ -1077,6 +1077,16 @@ export class YaverFeedback {
       }
       return base;
     }
+    // Backend approval makes the installation eligible; it does not mean the
+    // tester is currently in Dogfood. Keep all in-app controls absent until
+    // enableDeviceDogfood() has minted a live scoped session, and make Exit
+    // Dogfood actually remove both the gesture and fallback Y.
+    if (!YaverFeedback.getDogfoodStatus().active) {
+      if (typeof native?.setEnabled === 'function') {
+        await native.setEnabled(false, 900).catch(() => undefined);
+      }
+      return { ...base, reason: 'dogfood-session-inactive' };
+    }
     if (IS_HOST_MODE || isRunningInsideYaverHost()) {
       if (typeof native?.setEnabled === 'function') {
         await native.setEnabled(false, 900).catch(() => undefined);

package/src/__tests__/DogfoodRuntime.test.ts

@@ -124,6 +124,21 @@ describe('Dogfood lanes and console events', () => {
     expect(swift.map((option) => [option.lane, option.supported])).toEqual([
       ['browser', false], ['hermes', false], ['webrtc', true],
     ]);
+    expect(dogfoodLaneOptions('kotlin', { nativeRuntimeAvailable: true })
+      .map((option) => [option.lane, option.supported])).toEqual([
+      ['browser', false], ['hermes', false], ['webrtc', true],
+    ]);
+    expect(defaultDogfoodLane('swift', { nativeRuntimeAvailable: true })).toBe('webrtc');
+  });
+
+  test('a detected browser target adds real framework exceptions such as SwiftWasm', () => {
+    const swiftWasm = dogfoodLaneOptions('swift', {
+      nativeRuntimeAvailable: false,
+      browserRuntimeAvailable: true,
+    });
+    expect(swiftWasm.map((option) => [option.lane, option.supported])).toEqual([
+      ['browser', true], ['hermes', false], ['webrtc', false],
+    ]);
   });
 
   test('reads raw and replayed package-manager logs from /dev/events', () => {

package/src/__tests__/FeedbackModalContract.test.ts

@@ -0,0 +1,80 @@
+import { readFileSync } from 'fs';
+import { join } from 'path';
+import {
+  FEEDBACK_DOGFOOD_CONSOLE_COLORS,
+  FEEDBACK_DOGFOOD_LIGHT_COLORS,
+} from '../FeedbackModalTheme';
+
+const SOURCE_PATH = join(__dirname, '..', 'FeedbackModal.tsx');
+
+describe('FeedbackModal authenticated chat contract', () => {
+  const source = readFileSync(SOURCE_PATH, 'utf8');
+
+  it('themes every shared Dogfood surface for the light feedback sheet', () => {
+    expect(source).toMatch(/<DogfoodStatusRail[\s\S]*?colors=\{FEEDBACK_DOGFOOD_LIGHT_COLORS\}/);
+    expect(source).toMatch(/<DogfoodLanePicker[\s\S]*?colors=\{FEEDBACK_DOGFOOD_LIGHT_COLORS\}/);
+    expect(source).toMatch(/<DogfoodLiveConsole[\s\S]*?colors=\{FEEDBACK_DOGFOOD_CONSOLE_COLORS\}/);
+  });
+
+  it('keeps normal light-sheet copy at WCAG AA contrast', () => {
+    const rgb = (hex: string) => hex.match(/[a-f\d]{2}/gi)!.map((part) => parseInt(part, 16) / 255);
+    const luminance = (hex: string) => {
+      const channels = rgb(hex).map((channel) => channel <= 0.03928
+        ? channel / 12.92
+        : ((channel + 0.055) / 1.055) ** 2.4);
+      return 0.2126 * channels[0] + 0.7152 * channels[1] + 0.0722 * channels[2];
+    };
+    const ratio = (foreground: string, background: string) => {
+      const [lighter, darker] = [luminance(foreground), luminance(background)].sort((a, b) => b - a);
+      return (lighter + 0.05) / (darker + 0.05);
+    };
+
+    for (const foreground of [
+      FEEDBACK_DOGFOOD_LIGHT_COLORS.text,
+      FEEDBACK_DOGFOOD_LIGHT_COLORS.muted,
+      FEEDBACK_DOGFOOD_LIGHT_COLORS.accent,
+      FEEDBACK_DOGFOOD_LIGHT_COLORS.ready,
+      FEEDBACK_DOGFOOD_LIGHT_COLORS.attention,
+      FEEDBACK_DOGFOOD_LIGHT_COLORS.blocked,
+    ]) {
+      expect(ratio(foreground, FEEDBACK_DOGFOOD_LIGHT_COLORS.background)).toBeGreaterThanOrEqual(4.5);
+    }
+    expect(ratio(FEEDBACK_DOGFOOD_CONSOLE_COLORS.text, FEEDBACK_DOGFOOD_CONSOLE_COLORS.console))
+      .toBeGreaterThanOrEqual(4.5);
+    expect(ratio(FEEDBACK_DOGFOOD_CONSOLE_COLORS.muted, FEEDBACK_DOGFOOD_CONSOLE_COLORS.console))
+      .toBeGreaterThanOrEqual(4.5);
+  });
+
+  it('uses Chat as the authenticated entry surface without legacy command buttons', () => {
+    expect(source).toContain("setActiveTab(authenticated ? 'chat' : 'settings')");
+    expect(source).toContain('setShowVibeInput(authenticated || directDogfood)');
+    expect(source).not.toContain('Screenshot & Fix');
+    expect(source).not.toContain('<DeployPanel');
+  });
+
+  it('keeps Dogfood setup to box, runner, and checkout before asking for a runtime', () => {
+    const setupSteps = source.match(/const dogfoodSetupSteps = \[([\s\S]*?)\n  \];/)?.[1] || '';
+    expect([...setupSteps.matchAll(/key: '([^']+)'/g)].map((match) => match[1]))
+      .toEqual(['box', 'runner', 'checkout']);
+    expect(setupSteps).not.toContain("key: 'oauth'");
+    expect(setupSteps).not.toContain("key: 'installation'");
+    expect(setupSteps).not.toContain("key: 'model'");
+    expect(setupSteps).not.toContain("key: 'lane'");
+    expect(source).toContain("type DogfoodSetupStage = 'setup' | 'lane' | 'runtime'");
+    expect(source).toContain('label="Choose runtime"');
+  });
+
+  it('passes the selected native target and labels the live log source', () => {
+    expect(source).toContain("nativeTargetId: dogfoodLane === 'webrtc' ? dogfoodNativeTargetId : undefined");
+    expect(source).toMatch(/<DogfoodLiveConsole[\s\S]*?sourceLabel=\{dogfoodSourceLabel\}/);
+    expect(source).toContain('Simulator, emulator, or device');
+  });
+
+  it('has one iOS keyboard inset owner and no gesture-stealing sheet Pressable', () => {
+    expect(source).toContain('automaticallyAdjustKeyboardInsets={Platform.OS === \'ios\'}');
+    expect(source).not.toContain('<KeyboardAvoidingView');
+    expect(source).not.toContain('keyboardInset');
+    expect(source).toContain('<Pressable style={styles.backdrop} onPress={handleClose}');
+    expect(source).toMatch(/<View[\s\S]{0,300}?style=\{\[\s*styles\.modal/);
+  });
+});

package/src/__tests__/NativeDogfoodShortcut.test.ts

@@ -3,12 +3,37 @@ import { join } from 'path';
 
 const plugin = require('../../app.plugin.js') as {
   __test: {
+    patchHotReloadBootConfirmation(contents: string): string;
     patchDogfoodAppShortcut(contents: string): string;
     patchDogfoodSceneDelegate(contents: string): string;
   };
 };
 
 describe('native Dogfood shortcut contract', () => {
+  it('never treats process uptime as a successful React render', () => {
+    const staleHook = `
+    // Crash-revert safety net: clear the boot-attempt counter once
+    // RN renders its first frame, OR after 10 s of uptime — whichever
+    // fires first. If neither fires (bundle crashes before render),
+    // YaverHotReload.bundleURL() will eventually revert to the
+    // TestFlight-installed bundle after 3 failed boots. See
+    // YaverHotReload.swift for the full state machine.
+    NotificationCenter.default.addObserver(
+      forName: NSNotification.Name(rawValue: "RCTContentDidAppearNotification"),
+      object: nil,
+      queue: .main
+    ) { _ in YaverHotReload.markBootSuccessful() }
+    DispatchQueue.main.asyncAfter(deadline: .now() + 10) {
+      YaverHotReload.markBootSuccessful()
+    }
+`;
+    const patched = plugin.__test.patchHotReloadBootConfirmation(staleHook);
+    expect(patched).toContain('RCTContentDidAppearNotification');
+    expect(patched).toContain('only a real first React frame confirms boot');
+    expect(patched).not.toContain('asyncAfter(deadline: .now() + 10)');
+    expect(plugin.__test.patchHotReloadBootConfirmation(patched)).toBe(patched);
+  });
+
   it('patches cold and warm iOS shortcut delivery idempotently', () => {
     const source = `
 public class AppDelegate: ExpoAppDelegate {

package/src/__tests__/P2PDogfoodDriver.test.ts

@@ -50,12 +50,16 @@ describe('createP2PDogfoodDriver', () => {
       })),
       stopDogfoodRemoteRuntime: closeRuntime,
     } as unknown as P2PClient;
+    const snapshots: string[][] = [];
     const controller = new DogfoodController(
       { name: 'Native app', framework: 'flutter', workDir: '/workspace/app', lane: 'webrtc' },
       createP2PDogfoodDriver(client),
+      { onChange: (snapshot) => snapshots.push(snapshot.logs.map((line) => line.text)) },
     );
 
     await expect(controller.trigger()).resolves.toMatchObject({ lane: 'webrtc', sessionId: 'runtime-1' });
+    expect(snapshots.flat()).toContain('[runtime] source · iPhone simulator');
+    expect(snapshots.flat()).toContain('[runtime] starting');
     expect(closeRuntime).not.toHaveBeenCalled();
     await controller.stop();
     expect(closeRuntime).toHaveBeenCalledWith('runtime-1');

package/src/__tests__/YaverFeedback.test.ts

@@ -72,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 () => {
@@ -187,8 +208,7 @@ describe('YaverFeedback', () => {
     });
 
     it('keeps the Y visible until the authorized phone has completed onboarding', async () => {
-      YaverFeedback.init({ bundleId: 'io.example.app', dogfood: {} });
-      YaverFeedback.getConfig()!.dogfood!.controlGesture = true;
+      initActiveDogfood();
       jest.spyOn(YaverFeedback, 'getDogfoodAccess').mockResolvedValueOnce({
         appId: 'io.example.app',
         yaverAuthenticated: true,
@@ -210,8 +230,7 @@ describe('YaverFeedback', () => {
     });
 
     it('uses the invisible three-finger hold only after onboarding selects it', async () => {
-      YaverFeedback.init({ bundleId: 'io.example.app', dogfood: {} });
-      YaverFeedback.getConfig()!.dogfood!.controlGesture = true;
+      initActiveDogfood();
       jest.spyOn(YaverFeedback, 'getDogfoodAccess').mockResolvedValueOnce({
         appId: 'io.example.app',
         yaverAuthenticated: true,
@@ -235,8 +254,7 @@ describe('YaverFeedback', () => {
     });
 
     it('keeps the Y when native capability reports support but enabling the gesture fails', async () => {
-      YaverFeedback.init({ bundleId: 'io.example.app', dogfood: {} });
-      YaverFeedback.getConfig()!.dogfood!.controlGesture = true;
+      initActiveDogfood();
       jest.spyOn(YaverFeedback, 'getDogfoodAccess').mockResolvedValueOnce({
         appId: 'io.example.app',
         yaverAuthenticated: true,
@@ -264,8 +282,7 @@ describe('YaverFeedback', () => {
     });
 
     it('persists first-run completion for the exact account app installation', async () => {
-      YaverFeedback.init({ authToken: 'owner-token', bundleId: 'io.example.app', dogfood: {} });
-      YaverFeedback.getConfig()!.dogfood!.controlGesture = true;
+      initActiveDogfood({ authToken: 'owner-token' });
       jest.spyOn(YaverFeedback, 'getDogfoodAccess').mockResolvedValueOnce({
         appId: 'io.example.app',
         yaverAuthenticated: true,
@@ -288,8 +305,7 @@ describe('YaverFeedback', () => {
     });
 
     it('falls back to the minimized Y when accessibility owns multi-touch', async () => {
-      YaverFeedback.init({ bundleId: 'io.example.app', dogfood: {} });
-      YaverFeedback.getConfig()!.dogfood!.controlGesture = { durationMs: 1200 };
+      initActiveDogfood({ controlGesture: { durationMs: 1200 } });
       jest.spyOn(YaverFeedback, 'getDogfoodAccess').mockResolvedValueOnce({
         appId: 'io.example.app',
         yaverAuthenticated: true,
@@ -311,13 +327,25 @@ describe('YaverFeedback', () => {
     });
 
     it('suppresses guest controls inside the Yaver split-view container', async () => {
-      YaverFeedback.init({ bundleId: 'io.example.app', dogfood: {} });
-      YaverFeedback.getConfig()!.dogfood!.controlGesture = true;
+      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/index.ts

@@ -1,11 +1,10 @@
 /**
  * yaver-feedback-react-native — Visual feedback SDK for Yaver.
  *
- * Shake-to-report surface with three launch actions:
- *  1. Hot Reload              — instant JS reload
- *  2. Vibing                  — open a vibing session on the agent
- *  3. Screenshot & Fix        — capture the current screen and trigger
- *                               the fix loop
+ * Shake-to-report surface with one primary action: Chat. The connected agent
+ * receives the current-screen context and can use its MCP tools for fixes,
+ * reloads, and deploys without duplicating those commands as modal buttons.
+ * Machine, runner, model, and Dogfood configuration remain under Settings.
  *
  * The small quick-access icon stays hidden until the first shake by
  * default on mobile, then remains available unless the user hides it.