fix(rn-device): close iOS-MVP coverage gaps + strip upstream branding

Live pre-merge validation (docs/proof/ios-mvp-validation/REPORT.md in
workspace) surfaced 6 substantive bugs where iOS device verbs still
routed through the legacy agent-device daemon/CLI — exactly the surface
PR #164 was supposed to eliminate. This commit closes those gaps and
removes the leftover upstream visual branding.

API migration:
- rn-fast-runner-client.ts: drop dead per-endpoint helpers
  (fastTap/fastType/fastSnapshot/fastScreenshot/fastDismissKeyboard,
  plus their postJSON/postBinary plumbing). Rewrite fastSwipe to POST
  the single /command endpoint with command='drag' (the Swift .swipe
  case is tvOS-only; iOS coord gestures use .drag).
- RunIOSArgs: add 'drag' | 'longPress' | 'pinch' | 'findText' command
  variants + scale field for pinch.
- runIOS body builder: forward args.scale to the runner.
- agent-device-wrapper.ts: expand RN_FAST_RUNNER_COMMANDS to include
  swipe / scroll / longpress / pinch so runAgentDevice short-circuits
  through runIOS for all iOS device verbs.
- buildRunIOSArgs: new cases for swipe+scroll (→ .drag), longpress
  (→ .longPress), pinch (→ .pinch).
- device-interact.ts createDeviceFindHandler: on iOS the non-exact path
  now uses the snapshot-based findInLatestSnapshot orchestrator instead
  of the legacy `agent-device find` CLI (which respawned the upstream
  AgentDeviceRunner via the daemon and stole focus from RnFastRunner).
- device-interact.ts createDeviceScrollIntoViewHandler: new TS
  orchestrator scrollIntoViewIOS — snapshot → find → decideScroll →
  fastSwipe loop (up to 12 iterations). Android keeps the legacy CLI
  delegate (its daemon doesn't have the focus race).

Branding cleanup (live finding: "rn fast runner has agent device
runner logo / intro screen as well"):
- ContentView.swift: drop Image("Logo") + Image("PoweredBy"); show
  only the "rn-dev-agent / fast runner" text + "XCUITest bridge" tag.
- Assets.xcassets: delete Logo.imageset and PoweredBy.imageset
  imagesets entirely. Remove logo.jpg from AppIcon.appiconset and
  clear the filename reference in Contents.json so the runner uses
  Xcode's default placeholder icon (the runner ideally never
  foregrounds anyway, per the Task 2 regression XCTest).

Validation: existing 1449/1449 unit tests still pass. Swift TEST
BUILD SUCCEEDED. Live re-validation pending /reload-plugins.

Findings refs: docs/proof/ios-mvp-validation/REPORT.md (workspace).

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

Author: Lykhoyda

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

@@ -259,11 +259,14 @@ export function getAdbSerial() {
 // the new client expects. The legacy daemon + CLI tiers below remain — they
 // now serve Android exclusively.
 //
-// Commands intentionally NOT in this set:
-//   - longpress (Swift runner has no longPress-by-ref code path; if needed,
-//     callers can compose tap with durationMs)
-//   - swipe / scroll already route through fast-runner directly inside
-//     device-interact.ts via fastSwipe(), bypassing runAgentDevice entirely.
+// GH #105 iOS-MVP follow-up (post-validation): the original short-circuit
+// list left `swipe` / `scroll` / `longpress` / `pinch` / `find` on the
+// legacy daemon/CLI path. Live validation showed the daemon respawns the
+// upstream AgentDeviceRunner on every such call, which then fights our
+// RnFastRunner for focus. Each of these now routes through the runner's
+// `/command` endpoint (the Swift `.drag` / `.longPress` / `.pinch` / `.findText`
+// handlers). Coordinate-based gestures: the Swift `.swipe` case is tvOS-only;
+// iOS coordinate-form swipes/scrolls use `.drag`.
 const RN_FAST_RUNNER_COMMANDS = new Set([
     'snapshot',
     'tap',
@@ -273,6 +276,10 @@ const RN_FAST_RUNNER_COMMANDS = new Set([
     'back',
     'screenshot',
     'keyboard',
+    'swipe',
+    'scroll',
+    'longpress',
+    'pinch',
 ]);
 export function getCachedScreenRect() {
     return getScreenRect();
@@ -319,6 +326,69 @@ function buildRunIOSArgs(cliArgs, bundleId) {
             return { command: 'screenshot', ...(bundleId ? { bundleId } : {}) };
         case 'keyboard':
             return { command: 'dismissKeyboard', ...(bundleId ? { bundleId } : {}) };
+        case 'swipe':
+        case 'scroll': {
+            // Coordinate-based gesture. The Swift `.swipe` is tvOS-only; iOS
+            // coord-form gestures use `.drag`. CLI shapes seen:
+            //   ['swipe',  x1, y1, x2, y2, durationMs?]
+            //   ['scroll', x1, y1, x2, y2, durationMs?]
+            // Direction-form (`['scroll', 'down', amount?]`) cannot reach this
+            // path: device-interact converts direction→coords up-front and
+            // dispatches the coord shape.
+            const [x1S, y1S, x2S, y2S, durationS] = positionals;
+            const x1 = Number(x1S), y1 = Number(y1S), x2 = Number(x2S), y2 = Number(y2S);
+            if ([x1, y1, x2, y2].some((n) => Number.isNaN(n))) {
+                throw new Error(`buildRunIOSArgs: ${cmd} requires four numeric coordinates`);
+            }
+            const args = {
+                command: 'drag', x: x1, y: y1, x2, y2,
+                ...(bundleId ? { bundleId } : {}),
+            };
+            if (durationS !== undefined) {
+                const n = Number(durationS);
+                if (!Number.isNaN(n))
+                    args.durationMs = n;
+            }
+            return args;
+        }
+        case 'longpress': {
+            // CLI shape: ['longpress', x, y, durationMs?]
+            const [xS, yS, durationS] = positionals;
+            const x = Number(xS), y = Number(yS);
+            if (Number.isNaN(x) || Number.isNaN(y)) {
+                throw new Error(`buildRunIOSArgs: longpress requires numeric x, y`);
+            }
+            const args = {
+                command: 'longPress', x, y,
+                ...(bundleId ? { bundleId } : {}),
+            };
+            if (durationS !== undefined) {
+                const n = Number(durationS);
+                if (!Number.isNaN(n))
+                    args.durationMs = n;
+            }
+            return args;
+        }
+        case 'pinch': {
+            // CLI shape: ['pinch', scale, x?, y?]
+            const [scaleS, xS, yS] = positionals;
+            const scale = Number(scaleS);
+            if (Number.isNaN(scale)) {
+                throw new Error(`buildRunIOSArgs: pinch requires numeric scale`);
+            }
+            const args = {
+                command: 'pinch', scale,
+                ...(bundleId ? { bundleId } : {}),
+            };
+            if (xS !== undefined && yS !== undefined) {
+                const x = Number(xS), y = Number(yS);
+                if (!Number.isNaN(x))
+                    args.x = x;
+                if (!Number.isNaN(y))
+                    args.y = y;
+            }
+            return args;
+        }
         default:
             throw new Error(`buildRunIOSArgs: unsupported command "${cmd ?? '<empty>'}"`);
     }

scripts/cdp-bridge/dist/runners/rn-fast-runner-client.js

@@ -197,63 +197,12 @@ export function stopFastRunner() {
     }
     catch { /* ignore */ }
 }
-// --- HTTP client (legacy /tap, /snapshot routes — kept for device-interact.ts swipe + other callers) ---
-async function postJSON(path, body) {
-    if (!runnerState)
-        throw new Error('Fast runner not started');
-    const url = `http://[::1]:${runnerState.port}${path}`;
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), HTTP_TIMEOUT_MS);
-    try {
-        const res = await fetch(url, {
-            method: 'POST',
-            headers: body ? { 'Content-Type': 'application/json' } : undefined,
-            body: body ? JSON.stringify(body) : undefined,
-            signal: controller.signal,
-        });
-        if (!res.ok) {
-            const text = await res.text();
-            throw new Error(`HTTP ${res.status}: ${text}`);
-        }
-        return await res.json();
-    }
-    finally {
-        clearTimeout(timer);
-    }
-}
-async function postBinary(path) {
-    if (!runnerState)
-        throw new Error('Fast runner not started');
-    const url = `http://[::1]:${runnerState.port}${path}`;
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), HTTP_TIMEOUT_MS);
-    try {
-        const res = await fetch(url, { method: 'POST', signal: controller.signal });
-        if (!res.ok)
-            throw new Error(`HTTP ${res.status}`);
-        return Buffer.from(await res.arrayBuffer());
-    }
-    finally {
-        clearTimeout(timer);
-    }
-}
-export async function fastTap(x, y, duration) {
-    return postJSON('/tap', { x, y, ...(duration != null ? { duration } : {}) });
-}
-export async function fastType(text) {
-    return postJSON('/type', { text });
-}
 export async function fastSwipe(x1, y1, x2, y2, durationMs) {
-    return postJSON('/swipe', { x1, y1, x2, y2, ...(durationMs != null ? { durationMs } : {}) });
-}
-export async function fastSnapshot(bundleId) {
-    return postJSON('/snapshot', bundleId ? { bundleId } : {});
-}
-export async function fastScreenshot() {
-    return postBinary('/screenshot');
-}
-export async function fastDismissKeyboard() {
-    return postJSON('/dismissKeyboard');
+    const body = { command: 'drag', x: x1, y: y1, x2, y2 };
+    if (durationMs != null)
+        body.durationMs = durationMs;
+    const resp = await postCommand(body);
+    return resp;
 }
 // --- Health check ---
 export async function fastHealthCheck() {
@@ -434,6 +383,8 @@ export async function runIOS(args) {
         body.durationMs = args.durationMs;
     if (args.direction !== undefined)
         body.direction = args.direction;
+    if (args.scale !== undefined)
+        body.scale = args.scale;
     if (args.interactiveOnly !== undefined)
         body.interactiveOnly = args.interactiveOnly;
     if (args.compact !== undefined)

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

@@ -206,6 +206,34 @@ export function createDeviceFindHandler() {
             }
             return failResult(`AMBIGUOUS_MATCH: exact "${args.text}" matched ${candidates.length} elements`, { code: 'AMBIGUOUS_MATCH', query: args.text, candidates, hint: 'Add index: N to pick one.' });
         }
+        // GH #105 iOS-MVP follow-up: on iOS, the legacy `agent-device find` CLI
+        // path respawns the upstream AgentDeviceRunner via the daemon, which then
+        // fights our RnFastRunner for focus. Use the snapshot-based orchestrator
+        // instead — same result without the daemon round-trip. Android still
+        // uses the CLI fuzzy matcher (its daemon doesn't have the same focus race).
+        const activeSession = getActiveSession();
+        if (activeSession?.platform === 'ios') {
+            const find = await fetchFindCandidates(args.text, false);
+            if (!find.ok) {
+                if (find.reason === 'runner-leak-unrecovered') {
+                    return runnerLeakFailResult(args.text, find.recoveryReason);
+                }
+                return failResult(`Snapshot unavailable — cannot resolve "${args.text}" on iOS`, { code: 'SNAPSHOT_UNAVAILABLE', query: args.text });
+            }
+            const { candidates, recoveredTier } = find;
+            if (candidates.length === 0) {
+                return failResult(`No element matches "${args.text}"`, { code: 'NOT_FOUND', query: args.text });
+            }
+            if (candidates.length === 1) {
+                return tagPressIfRecovered(await pressCandidate(candidates[0], args.action), recoveredTier);
+            }
+            return failResult(`AMBIGUOUS_MATCH: "${args.text}" matched ${candidates.length} elements. Use device_press with one of these refs, or retry with index: N.`, {
+                code: 'AMBIGUOUS_MATCH',
+                query: args.text,
+                candidates,
+                hint: 'Pick the correct ref (prefer one with hittable=true) and call device_press(ref="...") directly, or call device_find again with index: N.',
+            });
+        }
         const cliArgs = ['find', args.text];
         if (args.action)
             cliArgs.push(args.action);
@@ -701,17 +729,81 @@ export function createDeviceScrollHandler() {
     });
 }
 export function createDeviceScrollIntoViewHandler() {
-    return withSession((args) => {
+    return withSession(async (args) => {
+        if (!args.ref && !args.text) {
+            return failResult('Provide either text or ref to scroll into view');
+        }
+        // GH #105 iOS-MVP follow-up: the Swift runner has no `scrollintoview`
+        // command; this is TS-orchestrated on iOS (snapshot → find → swipe loop).
+        // Android keeps the legacy CLI delegate (agent-device handles it natively).
+        const session = getActiveSession();
+        if (session?.platform === 'ios') {
+            return scrollIntoViewIOS(args);
+        }
         if (args.ref) {
             const ref = args.ref.startsWith('@') ? args.ref : `@${args.ref}`;
             return runAgentDevice(['scrollintoview', ref]);
         }
-        if (args.text) {
-            return runAgentDevice(['scrollintoview', args.text]);
-        }
-        return Promise.resolve(failResult('Provide either text or ref to scroll into view'));
+        return runAgentDevice(['scrollintoview', args.text]);
     });
 }
+/**
+ * GH #105 iOS-MVP follow-up: TS orchestrator for device_scrollintoview on iOS.
+ * Loops snapshot → find → check viewport → swipe up to MAX_ITERATIONS times.
+ * Uses the runner's `/command` snapshot + drag verbs exclusively — no daemon.
+ */
+async function scrollIntoViewIOS(args) {
+    const MAX_ITERATIONS = 12;
+    const screen = getCachedScreenRect() ?? DEFAULT_SCREEN;
+    const screenRect = { x: 0, y: 0, width: screen.width, height: screen.height };
+    for (let i = 0; i < MAX_ITERATIONS; i++) {
+        const snapRes = await runAgentDevice(['snapshot', '-i']);
+        if (snapRes.isError) {
+            return failResult(`scrollintoview: snapshot failed at iteration ${i}: ${snapRes.content?.[0]?.text ?? 'unknown'}`, { code: 'SNAPSHOT_UNAVAILABLE' });
+        }
+        let nodes = [];
+        try {
+            const envelope = JSON.parse(snapRes.content?.[0]?.text ?? '{}');
+            nodes = envelope.data?.nodes ?? [];
+        }
+        catch {
+            return failResult(`scrollintoview: failed to parse snapshot envelope at iteration ${i}`);
+        }
+        const target = args.ref
+            ? nodes.find((n) => n.ref === (args.ref.startsWith('@') ? args.ref : `@${args.ref}`)) ?? null
+            : findInLatestSnapshot(nodes, args.text);
+        if (!target) {
+            // Element not in snapshot at all; can't decide direction. Probably needs
+            // initial scroll. Default to swiping up (down-direction-of-content) once
+            // and retry — common case is reaching a below-fold element.
+            if (i === 0) {
+                const fallbackDir = decideScrollDirection({ x: 0, y: screen.height * 2, width: 1, height: 1 }, screenRect);
+                const coords = computeSwipeFromDirection(fallbackDir ?? 'down', screen);
+                await fastSwipe(coords.x1, coords.y1, coords.x2, coords.y2, DEFAULT_SWIPE_DURATION_MS);
+                continue;
+            }
+            return failResult(`scrollintoview: element "${args.ref ?? args.text}" not found after ${i} swipe iteration(s)`, { code: 'NOT_FOUND', iterations: i });
+        }
+        if (!target.rect) {
+            return failResult(`scrollintoview: target has no rect — cannot decide direction`);
+        }
+        const direction = decideScrollDirection(target.rect, screenRect);
+        if (direction === null) {
+            return okResult({
+                ref: target.ref,
+                rect: target.rect,
+                iterations: i,
+                method: 'fast-runner',
+            });
+        }
+        const coords = computeSwipeFromDirection(direction, screen);
+        const swipeResp = await fastSwipe(coords.x1, coords.y1, coords.x2, coords.y2, DEFAULT_SWIPE_DURATION_MS);
+        if (!swipeResp.ok) {
+            return failResult(`scrollintoview: swipe failed at iteration ${i}: ${swipeResp.error ?? 'unknown'}`);
+        }
+    }
+    return failResult(`scrollintoview: target "${args.ref ?? args.text}" did not enter viewport after ${MAX_ITERATIONS} swipe iterations`, { code: 'SCROLL_EXHAUSTED', iterations: MAX_ITERATIONS });
+}
 export function createDevicePinchHandler() {
     return withSession((args) => {
         const cliArgs = ['pinch', String(args.scale)];

scripts/cdp-bridge/src/agent-device-wrapper.ts

@@ -290,11 +290,14 @@ export function getAdbSerial(): string[] {
 // the new client expects. The legacy daemon + CLI tiers below remain — they
 // now serve Android exclusively.
 //
-// Commands intentionally NOT in this set:
-//   - longpress (Swift runner has no longPress-by-ref code path; if needed,
-//     callers can compose tap with durationMs)
-//   - swipe / scroll already route through fast-runner directly inside
-//     device-interact.ts via fastSwipe(), bypassing runAgentDevice entirely.
+// GH #105 iOS-MVP follow-up (post-validation): the original short-circuit
+// list left `swipe` / `scroll` / `longpress` / `pinch` / `find` on the
+// legacy daemon/CLI path. Live validation showed the daemon respawns the
+// upstream AgentDeviceRunner on every such call, which then fights our
+// RnFastRunner for focus. Each of these now routes through the runner's
+// `/command` endpoint (the Swift `.drag` / `.longPress` / `.pinch` / `.findText`
+// handlers). Coordinate-based gestures: the Swift `.swipe` case is tvOS-only;
+// iOS coordinate-form swipes/scrolls use `.drag`.
 
 const RN_FAST_RUNNER_COMMANDS = new Set<string>([
   'snapshot',
@@ -305,6 +308,10 @@ const RN_FAST_RUNNER_COMMANDS = new Set<string>([
   'back',
   'screenshot',
   'keyboard',
+  'swipe',
+  'scroll',
+  'longpress',
+  'pinch',
 ]);
 
 export function getCachedScreenRect(): { width: number; height: number } | null {
@@ -356,6 +363,65 @@ function buildRunIOSArgs(
       return { command: 'screenshot', ...(bundleId ? { bundleId } : {}) };
     case 'keyboard':
       return { command: 'dismissKeyboard', ...(bundleId ? { bundleId } : {}) };
+    case 'swipe':
+    case 'scroll': {
+      // Coordinate-based gesture. The Swift `.swipe` is tvOS-only; iOS
+      // coord-form gestures use `.drag`. CLI shapes seen:
+      //   ['swipe',  x1, y1, x2, y2, durationMs?]
+      //   ['scroll', x1, y1, x2, y2, durationMs?]
+      // Direction-form (`['scroll', 'down', amount?]`) cannot reach this
+      // path: device-interact converts direction→coords up-front and
+      // dispatches the coord shape.
+      const [x1S, y1S, x2S, y2S, durationS] = positionals;
+      const x1 = Number(x1S), y1 = Number(y1S), x2 = Number(x2S), y2 = Number(y2S);
+      if ([x1, y1, x2, y2].some((n) => Number.isNaN(n))) {
+        throw new Error(`buildRunIOSArgs: ${cmd} requires four numeric coordinates`);
+      }
+      const args: import('./runners/rn-fast-runner-client.js').RunIOSArgs = {
+        command: 'drag', x: x1, y: y1, x2, y2,
+        ...(bundleId ? { bundleId } : {}),
+      };
+      if (durationS !== undefined) {
+        const n = Number(durationS);
+        if (!Number.isNaN(n)) args.durationMs = n;
+      }
+      return args;
+    }
+    case 'longpress': {
+      // CLI shape: ['longpress', x, y, durationMs?]
+      const [xS, yS, durationS] = positionals;
+      const x = Number(xS), y = Number(yS);
+      if (Number.isNaN(x) || Number.isNaN(y)) {
+        throw new Error(`buildRunIOSArgs: longpress requires numeric x, y`);
+      }
+      const args: import('./runners/rn-fast-runner-client.js').RunIOSArgs = {
+        command: 'longPress', x, y,
+        ...(bundleId ? { bundleId } : {}),
+      };
+      if (durationS !== undefined) {
+        const n = Number(durationS);
+        if (!Number.isNaN(n)) args.durationMs = n;
+      }
+      return args;
+    }
+    case 'pinch': {
+      // CLI shape: ['pinch', scale, x?, y?]
+      const [scaleS, xS, yS] = positionals;
+      const scale = Number(scaleS);
+      if (Number.isNaN(scale)) {
+        throw new Error(`buildRunIOSArgs: pinch requires numeric scale`);
+      }
+      const args: import('./runners/rn-fast-runner-client.js').RunIOSArgs = {
+        command: 'pinch', scale,
+        ...(bundleId ? { bundleId } : {}),
+      };
+      if (xS !== undefined && yS !== undefined) {
+        const x = Number(xS), y = Number(yS);
+        if (!Number.isNaN(x)) args.x = x;
+        if (!Number.isNaN(y)) args.y = y;
+      }
+      return args;
+    }
     default:
       throw new Error(`buildRunIOSArgs: unsupported command "${cmd ?? '<empty>'}"`);
   }