feat: 13 bug fixes, cdp_set_shared_value tool, 148 tests (v0.22.0)

Benchmark-driven fixes from Liquid Glass 3-story validation:

Bug fixes:
- B103: cdp_navigate now verifies route arrival after fallback dispatch
- B106: device_scroll/swipe routes through fast-runner HID synthesis
- B107: deviceId parsing supports agent-device v0.8.0 response shape
- R1: Phase 5.5 auto-opens device session (skill update)
- R2: device_screenshot copies to requested output path
- R3: fast-runner process liveness check + auto-restart on death
- R4: UDID regex validation before ensureFastRunner
- R5: scroll amount semantics aligned between fast-runner and daemon
- R6: reload counter + NativeWind corruption warning in cdp_status
- R8: MCP-only proof capture enforcement in skill boundaries

New tool:
- cdp_set_shared_value: drive Reanimated animations by testID for
  proof captures when gesture synthesis is unavailable (D623)

Tests: 139 → 148 (+9 deviceId parsing unit tests)
Security: hono 4.12.12 → 4.12.14 (Dependabot #5)
Versions: plugin 0.22.0, MCP server 0.17.0
Decisions: D610-D625

Author: Lykhoyda

.claude-plugin/marketplace.json

@@ -9,7 +9,7 @@
     {
       "name": "rn-dev-agent",
       "description": "AI agent that fully tests React Native features on simulator/emulator — navigates the app, verifies UI, walks user flows, and confirms internal state.",
-      "version": "0.21.1",
+      "version": "0.22.0",
       "source": "./",
       "category": "mobile-development",
       "homepage": "https://github.com/Lykhoyda/rn-dev-agent"

.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "rn-dev-agent",
-  "version": "0.21.1",
+  "version": "0.22.0",
   "description": "AI agent that fully tests React Native features on simulator/emulator — navigates the app, verifies UI, walks user flows, and confirms internal state.",
   "author": {
     "name": "Anton Lykhoyda",

scripts/cdp-bridge/dist/agent-device-wrapper.js

@@ -1,12 +1,13 @@
 import { execFile as execFileCb } from 'node:child_process';
 import { promisify } from 'node:util';
-import { readFileSync, writeFileSync, unlinkSync, existsSync } from 'node:fs';
+import { readFileSync, writeFileSync, unlinkSync, existsSync, copyFileSync, mkdirSync } from 'node:fs';
 import { createConnection } from 'node:net';
-import { join } from 'node:path';
+import { join, dirname } from 'node:path';
 import { homedir } from 'node:os';
 import { okResult, failResult } from './utils.js';
 import { isFastRunnerAvailable, getFastRunnerState, fastTap, fastType, fastSwipe, fastSnapshot, fastScreenshot, fastDismissKeyboard, startFastRunner, } from './fast-runner-session.js';
 import { updateRefMap, refCenter, getScreenRect, hasRefMap, clearRefMap } from './fast-runner-ref-map.js';
+import { resolveBundleId } from './project-config.js';
 const execFile = promisify(execFileCb);
 const SESSION_FILE = '/tmp/rn-dev-agent-session.json';
 const EXEC_TIMEOUT = 30_000;
@@ -197,15 +198,36 @@ function computeSwipeCoords(direction, screen) {
     }
 }
 async function tryFastRunner(command, positionals) {
-    if (!isFastRunnerAvailable())
-        return null;
+    if (!isFastRunnerAvailable()) {
+        const session = getActiveSession();
+        if (session?.platform === 'ios' && session.deviceId) {
+            try {
+                await startFastRunner(session.deviceId, resolveBundleId('ios') ?? 'unknown');
+            }
+            catch { /* auto-restart failed */ }
+            if (!isFastRunnerAvailable())
+                return null;
+        }
+        else {
+            return null;
+        }
+    }
     const state = getFastRunnerState();
     try {
         switch (command) {
             case 'screenshot': {
                 const pngBuffer = await fastScreenshot();
                 const tmpPath = `/tmp/rn-fast-screenshot-${Date.now()}.png`;
                 writeFileSync(tmpPath, pngBuffer);
+                const requestedPath = positionals.find(p => !p.startsWith('-'));
+                if (requestedPath && requestedPath !== tmpPath) {
+                    try {
+                        mkdirSync(dirname(requestedPath), { recursive: true });
+                        copyFileSync(tmpPath, requestedPath);
+                        return okResult({ path: requestedPath, method: 'fast-runner' });
+                    }
+                    catch { /* fall through to tmpPath */ }
+                }
                 return okResult({ path: tmpPath, method: 'fast-runner' });
             }
             case 'snapshot': {

scripts/cdp-bridge/dist/fast-runner-session.js

@@ -26,7 +26,19 @@ export function getFastRunnerState() {
     return runnerState;
 }
 export function isFastRunnerAvailable() {
-    return runnerState !== null;
+    if (!runnerState)
+        return false;
+    try {
+        process.kill(runnerState.pid, 0);
+        return true;
+    }
+    catch { /* process dead */ }
+    runnerState = null;
+    try {
+        unlinkSync(STATE_FILE);
+    }
+    catch { /* ignore */ }
+    return false;
 }
 // --- Lifecycle ---
 export function startFastRunner(deviceId, bundleId, port = DEFAULT_PORT) {

scripts/cdp-bridge/dist/index.js

@@ -172,6 +172,71 @@ trackedTool('cdp_component_state', 'Inspect a specific component\'s full hook st
     }
     return okResult(parsed);
 }));
+trackedTool('cdp_set_shared_value', 'Set a Reanimated SharedValue on a component found by testID. Walks the React fiber tree to find the component, locates the named prop (a SharedValue object), and sets .value. Useful for driving Reanimated animations in proof captures when gesture/scroll synthesis is unavailable.', {
+    testID: z.string().describe('testID of the component that receives the SharedValue as a prop'),
+    prop: z.string().describe('Prop name containing the SharedValue (e.g. "scrollY", "progress")'),
+    value: z.number().describe('Numeric value to set on the SharedValue'),
+}, withConnection(getClient, async (args, client) => {
+    const expression = `(function() {
+      var hook = globalThis.__REACT_DEVTOOLS_GLOBAL_HOOK__;
+      if (!hook) return JSON.stringify({ __agent_error: 'No React DevTools hook' });
+      var ids = Array.from(hook.renderers.keys());
+      var allRoots = [];
+      for (var i = 0; i < ids.length; i++) {
+        var r = hook.getFiberRoots(ids[i]);
+        if (r && r.size) { var it = r.values(); var v; while (!(v = it.next()).done) allRoots.push(v.value); }
+      }
+      if (!allRoots.length) return JSON.stringify({ __agent_error: 'No fiber roots' });
+      var found = null;
+      function walk(fiber, depth) {
+        if (!fiber || depth > 300 || found) return;
+        var props = fiber.memoizedProps;
+        if (props && props.testID === ${JSON.stringify(args.testID)}) {
+          var sv = props[${JSON.stringify(args.prop)}];
+          if (sv && typeof sv === 'object' && 'value' in sv) { found = fiber; return; }
+          var fc = fiber;
+          for (var up = 0; up < 5 && fc; up++) {
+            var p2 = fc.memoizedProps;
+            if (p2 && p2[${JSON.stringify(args.prop)}] && typeof p2[${JSON.stringify(args.prop)}] === 'object' && 'value' in p2[${JSON.stringify(args.prop)}]) {
+              found = fc; return;
+            }
+            fc = fc.return;
+          }
+        }
+        if (fiber.child) walk(fiber.child, depth + 1);
+        if (fiber.sibling) walk(fiber.sibling, depth);
+      }
+      for (var ri = 0; ri < allRoots.length; ri++) walk(allRoots[ri].current, 0);
+      if (!found) return JSON.stringify({ __agent_error: 'No component with testID=' + ${JSON.stringify(args.testID)} + ' has a SharedValue prop named ' + ${JSON.stringify(args.prop)} });
+      var sv = found.memoizedProps[${JSON.stringify(args.prop)}];
+      if (!sv) {
+        var fc2 = found;
+        for (var up2 = 0; up2 < 5 && fc2; up2++) {
+          if (fc2.memoizedProps && fc2.memoizedProps[${JSON.stringify(args.prop)}]) { sv = fc2.memoizedProps[${JSON.stringify(args.prop)}]; break; }
+          fc2 = fc2.return;
+        }
+      }
+      if (!sv || typeof sv !== 'object' || !('value' in sv)) return JSON.stringify({ __agent_error: 'SharedValue prop found but not accessible on the resolved fiber' });
+      sv.value = ${args.value};
+      return JSON.stringify({ ok: true, testID: ${JSON.stringify(args.testID)}, prop: ${JSON.stringify(args.prop)}, value: ${args.value} });
+    })()`;
+    const result = await client.evaluate(expression);
+    if (result.error)
+        return failResult(`SharedValue error: ${result.error}`);
+    if (typeof result.value !== 'string')
+        return failResult('Unexpected response');
+    let parsed;
+    try {
+        parsed = JSON.parse(result.value);
+    }
+    catch {
+        return okResult({ raw: result.value });
+    }
+    if (parsed !== null && typeof parsed === 'object' && '__agent_error' in parsed) {
+        return failResult(String(parsed.__agent_error));
+    }
+    return okResult(parsed);
+}));
 trackedTool('cdp_dispatch', 'Dispatch a Redux action and optionally read state afterward — all in a single synchronous JS execution. Use for atomic dispatch+verify operations (e.g. dispatch "tasks/softDelete" then read "tasks.pendingDelete"). NOTE: Best used for state verification, not UI interaction testing — React components may not re-render immediately after CDP-dispatched actions. For UI testing, use device_press/device_find to trigger the action through the UI instead.', {
     action: z.string().describe('Redux action type (e.g. "tasks/softDelete", "cart/addItem")'),
     payload: z.any().optional().describe('Action payload'),

scripts/cdp-bridge/dist/injected-helpers.js

@@ -1066,6 +1066,22 @@ export const INJECTED_HELPERS = `
       }
 
       ref.navigate(screen, params || undefined);
+      var afterFallback = ref.getRootState();
+      var found = false;
+      function checkRoute(rs) {
+        if (!rs) return;
+        if (rs.name === screen) { found = true; return; }
+        if (rs.routes) {
+          for (var ri = 0; ri < rs.routes.length; ri++) {
+            checkRoute(rs.routes[ri]);
+            if (rs.routes[ri].state) checkRoute(rs.routes[ri].state);
+          }
+        }
+      }
+      checkRoute(afterFallback);
+      if (!found) {
+        return JSON.stringify({ __agent_error: 'Navigate failed: screen "' + screen + '" not found in any navigator after dispatch. Check screen name spelling and that it is registered in a navigator.' });
+      }
       return JSON.stringify({ navigated: true, screen: screen, method: 'fallback-navigate' });
 
     } catch(e) {

scripts/cdp-bridge/dist/tools/device-interact.js

@@ -1,6 +1,7 @@
 import { execFile as execFileCb } from 'node:child_process';
 import { promisify } from 'node:util';
 import { runAgentDevice, getActiveSession, getCachedScreenRect, getAdbSerial, cacheSnapshot } from '../agent-device-wrapper.js';
+import { isFastRunnerAvailable, fastSwipe } from '../fast-runner-session.js';
 import { withSession } from '../utils.js';
 import { okResult, failResult } from '../utils.js';
 import { runMaestroInline, yamlEscape } from '../maestro-invoke.js';
@@ -315,8 +316,22 @@ function computeSwipeFromDirection(direction, screen) {
     }
 }
 export function createDeviceSwipeHandler() {
-    return withSession((args) => {
+    return withSession(async (args) => {
+        // B106 fix: use fast-runner's HID-level synthesis to bypass XCTest
+        // `waitForIdle` hangs on Reanimated-driven screens. Only applies when
+        // fast-runner is available (iOS) and count/pattern are not used (those
+        // are daemon-specific features — fall back to agent-device for them).
+        const canUseFastRunner = isFastRunnerAvailable() && !args.count && !args.pattern;
         if (args.x1 != null && args.y1 != null && args.x2 != null && args.y2 != null) {
+            if (canUseFastRunner) {
+                try {
+                    const resp = await fastSwipe(args.x1, args.y1, args.x2, args.y2, args.durationMs);
+                    if (resp.ok) {
+                        return okResult({ x1: args.x1, y1: args.y1, x2: args.x2, y2: args.y2, durationMs: args.durationMs, method: 'fast-runner' });
+                    }
+                }
+                catch { /* fall through */ }
+            }
             const cliArgs = ['swipe', String(args.x1), String(args.y1), String(args.x2), String(args.y2)];
             if (args.durationMs)
                 cliArgs.push(String(args.durationMs));
@@ -328,23 +343,75 @@ export function createDeviceSwipeHandler() {
         }
         if (args.direction) {
             // B-Tier3 fix: Use real swipe gesture (not scroll) for direction-based swipes.
-            // The previous delegation to `scroll` produced smooth list scrolls that don't
-            // trigger gesture handlers (pull-to-refresh, swipe-to-delete).
             const screen = getCachedScreenRect() ?? DEFAULT_SCREEN;
             const coords = computeSwipeFromDirection(args.direction, screen);
             const duration = args.durationMs ?? DEFAULT_SWIPE_DURATION_MS;
+            if (canUseFastRunner) {
+                try {
+                    const resp = await fastSwipe(coords.x1, coords.y1, coords.x2, coords.y2, duration);
+                    if (resp.ok) {
+                        return okResult({ direction: args.direction, durationMs: duration, method: 'fast-runner', ...coords });
+                    }
+                }
+                catch { /* fall through */ }
+            }
             const cliArgs = ['swipe', String(coords.x1), String(coords.y1), String(coords.x2), String(coords.y2), String(duration)];
             if (args.count && args.count > 1)
                 cliArgs.push('--count', String(args.count));
             if (args.pattern)
                 cliArgs.push('--pattern', args.pattern);
             return runAgentDevice(cliArgs);
         }
-        return Promise.resolve(failResult('Provide either direction or x1,y1,x2,y2 coordinates'));
+        return failResult('Provide either direction or x1,y1,x2,y2 coordinates');
     });
 }
 export function createDeviceScrollHandler() {
-    return withSession((args) => {
+    return withSession(async (args) => {
+        // B106 fix: Route iOS scroll through fast-runner's direct HID synthesis
+        // when available. The agent-device daemon path uses XCTest's high-level
+        // gesture API which calls `waitForIdle` after the drag — this hangs
+        // indefinitely on screens driven by Reanimated `useAnimatedScrollHandler`
+        // because the UI thread is never "idle" between scroll events. Fast-runner
+        // uses `RunnerDaemonProxy.synthesize(eventRecord)` which is raw HID event
+        // injection and returns as soon as events are delivered.
+        if (isFastRunnerAvailable()) {
+            const screen = getCachedScreenRect() ?? DEFAULT_SCREEN;
+            const amount = Math.min(Math.max(args.amount ?? 0.5, 0), 1);
+            const cx = Math.round(screen.width / 2);
+            const cy = Math.round(screen.height / 2);
+            const dy = Math.round(screen.height * SWIPE_FRACTION * amount);
+            const dx = Math.round(screen.width * SWIPE_FRACTION * amount);
+            let x1 = cx, y1 = cy, x2 = cx, y2 = cy;
+            switch (args.direction) {
+                // "scroll down" = content moves up = finger moves up (swipe up)
+                case 'down':
+                    y1 = cy + Math.round(dy / 2);
+                    y2 = cy - Math.round(dy / 2);
+                    break;
+                case 'up':
+                    y1 = cy - Math.round(dy / 2);
+                    y2 = cy + Math.round(dy / 2);
+                    break;
+                case 'left':
+                    x1 = cx + Math.round(dx / 2);
+                    x2 = cx - Math.round(dx / 2);
+                    break;
+                case 'right':
+                    x1 = cx - Math.round(dx / 2);
+                    x2 = cx + Math.round(dx / 2);
+                    break;
+            }
+            try {
+                const resp = await fastSwipe(x1, y1, x2, y2, DEFAULT_SWIPE_DURATION_MS);
+                if (resp.ok) {
+                    return okResult({ direction: args.direction, amount: args.amount ?? 0.5, method: 'fast-runner', x1, y1, x2, y2 });
+                }
+                // Fall through to daemon on fast-runner failure
+            }
+            catch {
+                // Fall through to daemon on fast-runner error
+            }
+        }
         const cliArgs = ['scroll', args.direction];
         if (args.amount != null)
             cliArgs.push(String(args.amount));

scripts/cdp-bridge/dist/tools/device-session.js

@@ -32,7 +32,19 @@ export function createDeviceSnapshotHandler() {
                 let deviceId;
                 try {
                     const envelope = JSON.parse(result.content[0].text);
-                    deviceId = envelope?.data?.deviceId ?? envelope?.data?.device?.id;
+                    const data = envelope?.data;
+                    // agent-device `open` response shape (v0.8.0):
+                    //   data.id = device UDID (top-level)
+                    //   data.device_udid = UDID (duplicate)
+                    //   data.device = device NAME (string, e.g. "iPhone 17 Pro") — NOT an object
+                    //   data.deviceId = legacy field (older agent-device)
+                    // B107 fix: also read data.id / data.device_udid / (data.device.id when object).
+                    const rawId = data?.deviceId
+                        ?? data?.device_udid
+                        ?? data?.id
+                        ?? (typeof data?.device === 'object' ? data?.device?.id : undefined);
+                    const UDID_RE = /^[0-9A-Fa-f-]{25,}$/;
+                    deviceId = typeof rawId === 'string' && UDID_RE.test(rawId) ? rawId : undefined;
                 }
                 catch { /* best-effort */ }
                 setActiveSession({

scripts/cdp-bridge/dist/tools/reload.js

@@ -1,4 +1,6 @@
 import { okResult, failResult, warnResult, withConnection } from '../utils.js';
+let sessionReloadCount = 0;
+export function getSessionReloadCount() { return sessionReloadCount; }
 export function createReloadHandler(getClient) {
     return withConnection(getClient, async (_args, client) => {
         // Step 1: Trigger reload — expected to disconnect the WS
@@ -79,6 +81,7 @@ export function createReloadHandler(getClient) {
                 return warnResult({ reloaded: true, type: 'full', reconnected: true }, 'Reload succeeded but helper injection failed. App may still be loading — retry cdp_status.');
             }
         }
+        sessionReloadCount++;
         return okResult({ reloaded: true, type: 'full', reconnected: true });
     });
 }

scripts/cdp-bridge/dist/tools/status.js

@@ -1,5 +1,6 @@
 import { okResult, failResult, warnResult } from '../utils.js';
 import { handleDevClientPicker } from './dev-client-picker.js';
+import { getSessionReloadCount } from './reload.js';
 const STATUS_PROBE_EXPRESSION = `
 (function() {
   var result = { appInfo: null, errorCount: 0, fiberTree: false, hasRedBox: false, helpersLoaded: false };
@@ -145,6 +146,10 @@ export function createStatusHandler(getClient, setClient, createClient) {
                     return warnResult(status, 'Debugger is paused. Auto-recovery failed. Try cdp_reload(full=true).');
                 }
             }
+            const reloadCount = getSessionReloadCount();
+            if (reloadCount >= 5) {
+                return warnResult(status, `${reloadCount} full reloads in this session. NativeWind stylesheet may be corrupted — if the screen appears blank, restart Metro and relaunch the app.`);
+            }
             return okResult(status, autoRecoveredMessage ? { meta: { autoRecovered: autoRecoveredMessage } } : undefined);
         }
         catch (err) {