yaver-feedback-react-native 0.9.9 → 0.9.11

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/__tests__/DogfoodRuntime.test.ts

@@ -2,6 +2,7 @@ import {
   DogfoodController,
   DogfoodRuntimeError,
   defaultDogfoodLane,
+  dogfoodLanePlan,
   dogfoodLaneOptions,
   dogfoodLogLinesFromDevEvent,
   validateDogfoodProject,
@@ -92,6 +93,41 @@ describe('DogfoodController', () => {
     await controller.stop();
     expect(stopSecond).toHaveBeenCalledTimes(1);
   });
+
+  test('keeps a failed preferred lane in the console and automatically recovers through browser', async () => {
+    const stopPreferred = jest.fn();
+    const lanes: string[] = [];
+    const controller = new DogfoodController({
+      ...expo,
+      lane: 'hermes',
+      fallbackLane: 'browser',
+    }, {
+      async start(ctx) {
+        lanes.push(ctx.project.lane);
+        if (ctx.project.lane === 'hermes') {
+          ctx.registerCleanup(stopPreferred);
+          throw new DogfoodRuntimeError({
+            code: 'DOGFOOD_HERMES_BUILD_FAILED',
+            error: 'Hermes build failed',
+            remedy: 'Use the browser build.',
+            retryable: true,
+          });
+        }
+        return { lane: 'browser', url: 'http://agent/dev/', metadata: { recovered: true } };
+      },
+    });
+
+    await expect(controller.trigger()).resolves.toMatchObject({
+      lane: 'browser',
+      metadata: { fallbackFrom: 'hermes', fallbackReason: 'DOGFOOD_HERMES_BUILD_FAILED' },
+    });
+    expect(lanes).toEqual(['hermes', 'browser']);
+    expect(stopPreferred).toHaveBeenCalledTimes(1);
+    expect(controller.snapshot()).toMatchObject({ phase: 'ready', project: { lane: 'browser' } });
+    expect(controller.snapshot().logs.map((line) => line.text)).toContain(
+      '[fallback] hermes failed (DOGFOOD_HERMES_BUILD_FAILED); trying browser',
+    );
+  });
 });
 
 describe('Dogfood lanes and console events', () => {
@@ -112,6 +148,21 @@ describe('Dogfood lanes and console events', () => {
     expect(flutter.find((option) => option.lane === 'hermes')?.supported).toBe(false);
   });
 
+  test('uses browser as the framework-aware default and as second choice after an explicit native preference', () => {
+    expect(dogfoodLanePlan('flutter', { nativeRuntimeAvailable: true })).toMatchObject({
+      preferred: 'browser', fallback: undefined,
+    });
+    expect(dogfoodLanePlan('expo', { nativeRuntimeAvailable: true }, 'hermes')).toMatchObject({
+      preferred: 'hermes', fallback: 'browser',
+    });
+    expect(dogfoodLanePlan('flutter', { nativeRuntimeAvailable: true }, 'webrtc')).toMatchObject({
+      preferred: 'webrtc', fallback: 'browser',
+    });
+    expect(dogfoodLanePlan('swift', { nativeRuntimeAvailable: true }, 'webrtc')).toMatchObject({
+      preferred: 'webrtc', fallback: undefined,
+    });
+  });
+
   test('keeps Yaver self-development on the same RN three-lane contract', () => {
     const options = dogfoodLaneOptions('expo', { nativeRuntimeAvailable: true, selfDevelopment: true });
     expect(options).toHaveLength(3);
@@ -124,6 +175,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,88 @@
+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("useState<'chat' | 'settings'>('chat')");
+    expect(source).toContain('setShowVibeInput(authenticated || directDogfood)');
+    expect(source).not.toContain('Screenshot & Fix');
+    expect(source).not.toContain('<DeployPanel');
+  });
+
+  it('opens explicit Dogfood onboarding on setup and makes the runtime console the first live surface', () => {
+    expect(source).toContain("setActiveTab('settings')");
+    expect(source).toContain("setDogfoodSetupStage('runtime')");
+    expect(source).toMatch(/dogfoodSetupStage === 'runtime'[\s\S]*?<DogfoodLiveConsole/);
+  });
+
+  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: lanePlan.preferred === 'webrtc' ? dogfoodNativeTargetId : undefined");
+    expect(source).toContain('fallbackLane: lanePlan.fallback');
+    expect(source).toContain('fallbackLane={dogfoodLanePolicy.fallback}');
+    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/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.
@@ -93,6 +92,7 @@ export {
   DogfoodController,
   DogfoodRuntimeError,
   defaultDogfoodLane,
+  dogfoodLanePlan,
   dogfoodLaneOptions,
   dogfoodLogLinesFromDevEvent,
   runtimeLogLinesFromDevEvent,
@@ -104,6 +104,7 @@ export type {
   DogfoodFailure,
   DogfoodLane,
   DogfoodLaneOption,
+  DogfoodLanePlan,
   DogfoodLogLine,
   DogfoodPhase,
   DogfoodProject,