fix: support long-press on iOS simulators via XCTest runner

The long-press command was failing on iOS simulators because dispatch.ts
called interactor.longPress() which mapped to a stub in ios/index.ts
that always threw UNSUPPORTED_OPERATION. Unlike press, type, fill, etc.,
the long-press case was missing the iOS simulator routing through the
XCTest runner.

Rather than adding yet another platform branch in dispatch.ts, this
refactors the Interactor abstraction to absorb runner routing internally.
getInteractor() now accepts an optional RunnerContext; when the device is
an iOS simulator, it returns an interactor whose tap/longPress/focus/
type/fill/scroll/scrollIntoView methods route through
runIosRunnerCommand. This removes 7 scattered if-ios-simulator branches
from dispatch.ts, making it impossible to forget runner routing for
future commands.

Changes:
- Swift runner: add longPress command type + longPressAt helper using
  XCUICoordinate.press(forDuration:)
- runner-client.ts: add longPress to RunnerCommand type + durationMs field
- interactors.ts: add RunnerContext type, createIosSimulatorInteractor()
  that routes through the XCTest runner, move invertScrollDirection here
- dispatch.ts: pass RunnerContext to getInteractor, remove all iOS sim
  branching for interactor commands (-90 lines)

Co-authored-by: Cursor <cursoragent@cursor.com>

Author: thymikee

ios-runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerTests.swift

@@ -232,6 +232,13 @@ final class RunnerTests: XCTestCase {
         return Response(ok: true, data: DataPayload(message: "tapped"))
       }
       return Response(ok: false, error: ErrorPayload(message: "tap requires text or x/y"))
+    case .longPress:
+      guard let x = command.x, let y = command.y else {
+        return Response(ok: false, error: ErrorPayload(message: "longPress requires x and y"))
+      }
+      let duration = (command.durationMs ?? 800) / 1000.0
+      longPressAt(app: activeApp, x: x, y: y, duration: duration)
+      return Response(ok: true, data: DataPayload(message: "long pressed"))
     case .type:
       guard let text = command.text else {
         return Response(ok: false, error: ErrorPayload(message: "type requires text"))
@@ -411,6 +418,12 @@ final class RunnerTests: XCTestCase {
     coordinate.tap()
   }
 
+  private func longPressAt(app: XCUIApplication, x: Double, y: Double, duration: TimeInterval) {
+    let origin = app.coordinate(withNormalizedOffset: CGVector(dx: 0, dy: 0))
+    let coordinate = origin.withOffset(CGVector(dx: x, dy: y))
+    coordinate.press(forDuration: duration)
+  }
+
   private func swipe(app: XCUIApplication, direction: SwipeDirection) {
     let target = app.windows.firstMatch.exists ? app.windows.firstMatch : app
     let start = target.coordinate(withNormalizedOffset: CGVector(dx: 0.5, dy: 0.2))
@@ -792,6 +805,7 @@ private func resolveRunnerPort() -> UInt16 {
 
 enum CommandType: String, Codable {
   case tap
+  case longPress
   case type
   case swipe
   case findText
@@ -820,6 +834,7 @@ struct Command: Codable {
   let action: String?
   let x: Double?
   let y: Double?
+  let durationMs: Double?
   let direction: SwipeDirection?
   let scale: Double?
   let interactiveOnly: Bool?

src/core/dispatch.ts

@@ -12,7 +12,7 @@ import {
   snapshotAndroid,
 } from '../platforms/android/index.ts';
 import { listIosDevices } from '../platforms/ios/devices.ts';
-import { getInteractor } from '../utils/interactors.ts';
+import { getInteractor, type RunnerContext } from '../utils/interactors.ts';
 import { runIosRunnerCommand } from '../platforms/ios/runner-client.ts';
 import { snapshotAx } from '../platforms/ios/ax-snapshot.ts';
 import { setIosSetting } from '../platforms/ios/index.ts';
@@ -92,7 +92,13 @@ export async function dispatchCommand(
     snapshotBackend?: 'ax' | 'xctest';
   },
 ): Promise<Record<string, unknown> | void> {
-  const interactor = getInteractor(device);
+  const runnerCtx: RunnerContext = {
+    appBundleId: context?.appBundleId,
+    verbose: context?.verbose,
+    logPath: context?.logPath,
+    traceLogPath: context?.traceLogPath,
+  };
+  const interactor = getInteractor(device, runnerCtx);
   switch (command) {
     case 'open': {
       const app = positionals[0];
@@ -114,15 +120,7 @@ export async function dispatchCommand(
     case 'press': {
       const [x, y] = positionals.map(Number);
       if (Number.isNaN(x) || Number.isNaN(y)) throw new AppError('INVALID_ARGS', 'press requires x y');
-      if (device.platform === 'ios' && device.kind === 'simulator') {
-        await runIosRunnerCommand(
-          device,
-          { command: 'tap', x, y, appBundleId: context?.appBundleId },
-          { verbose: context?.verbose, logPath: context?.logPath, traceLogPath: context?.traceLogPath },
-        );
-      } else {
-        await interactor.tap(x, y);
-      }
+      await interactor.tap(x, y);
       return { x, y };
     }
     case 'long-press': {
@@ -138,29 +136,13 @@ export async function dispatchCommand(
     case 'focus': {
       const [x, y] = positionals.map(Number);
       if (Number.isNaN(x) || Number.isNaN(y)) throw new AppError('INVALID_ARGS', 'focus requires x y');
-      if (device.platform === 'ios' && device.kind === 'simulator') {
-        await runIosRunnerCommand(
-          device,
-          { command: 'tap', x, y, appBundleId: context?.appBundleId },
-          { verbose: context?.verbose, logPath: context?.logPath, traceLogPath: context?.traceLogPath },
-        );
-      } else {
-        await interactor.focus(x, y);
-      }
+      await interactor.focus(x, y);
       return { x, y };
     }
     case 'type': {
       const text = positionals.join(' ');
       if (!text) throw new AppError('INVALID_ARGS', 'type requires text');
-      if (device.platform === 'ios' && device.kind === 'simulator') {
-        await runIosRunnerCommand(
-          device,
-          { command: 'type', text, appBundleId: context?.appBundleId },
-          { verbose: context?.verbose, logPath: context?.logPath, traceLogPath: context?.traceLogPath },
-        );
-      } else {
-        await interactor.type(text);
-      }
+      await interactor.type(text);
       return { text };
     }
     case 'fill': {
@@ -170,62 +152,19 @@ export async function dispatchCommand(
       if (Number.isNaN(x) || Number.isNaN(y) || !text) {
         throw new AppError('INVALID_ARGS', 'fill requires x y text');
       }
-      if (device.platform === 'ios' && device.kind === 'simulator') {
-        await runIosRunnerCommand(
-          device,
-          { command: 'tap', x, y, appBundleId: context?.appBundleId },
-          { verbose: context?.verbose, logPath: context?.logPath, traceLogPath: context?.traceLogPath },
-        );
-        await runIosRunnerCommand(
-          device,
-          { command: 'type', text, clearFirst: true, appBundleId: context?.appBundleId },
-          { verbose: context?.verbose, logPath: context?.logPath, traceLogPath: context?.traceLogPath },
-        );
-      } else {
-        await interactor.fill(x, y, text);
-      }
+      await interactor.fill(x, y, text);
       return { x, y, text };
     }
     case 'scroll': {
       const direction = positionals[0];
       const amount = positionals[1] ? Number(positionals[1]) : undefined;
       if (!direction) throw new AppError('INVALID_ARGS', 'scroll requires direction');
-      if (device.platform === 'ios' && device.kind === 'simulator') {
-        if (!['up', 'down', 'left', 'right'].includes(direction)) {
-          throw new AppError('INVALID_ARGS', `Unknown direction: ${direction}`);
-        }
-        const inverted = invertScrollDirection(direction as 'up' | 'down' | 'left' | 'right');
-        await runIosRunnerCommand(
-          device,
-          { command: 'swipe', direction: inverted, appBundleId: context?.appBundleId },
-          { verbose: context?.verbose, logPath: context?.logPath, traceLogPath: context?.traceLogPath },
-        );
-      } else {
-        await interactor.scroll(direction, amount);
-      }
+      await interactor.scroll(direction, amount);
       return { direction, amount };
     }
     case 'scrollintoview': {
       const text = positionals.join(' ').trim();
       if (!text) throw new AppError('INVALID_ARGS', 'scrollintoview requires text');
-      if (device.platform === 'ios' && device.kind === 'simulator') {
-        const maxAttempts = 8;
-        for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
-          const found = (await runIosRunnerCommand(
-            device,
-            { command: 'findText', text, appBundleId: context?.appBundleId },
-            { verbose: context?.verbose, logPath: context?.logPath, traceLogPath: context?.traceLogPath },
-          )) as { found?: boolean };
-          if (found?.found) return { text, attempts: attempt + 1 };
-          await runIosRunnerCommand(
-            device,
-            { command: 'swipe', direction: 'up', appBundleId: context?.appBundleId },
-            { verbose: context?.verbose, logPath: context?.logPath, traceLogPath: context?.traceLogPath },
-          );
-          await new Promise((resolve) => setTimeout(resolve, 300));
-        }
-        throw new AppError('COMMAND_FAILED', `scrollintoview could not find text: ${text}`);
-      }
       await interactor.scrollIntoView(text);
       return { text };
     }
@@ -340,17 +279,3 @@ export async function dispatchCommand(
   }
 }
 
-function invertScrollDirection(direction: 'up' | 'down' | 'left' | 'right'): 'up' | 'down' | 'left' | 'right' {
-  switch (direction) {
-    case 'up':
-      return 'down';
-    case 'down':
-      return 'up';
-    case 'left':
-      return 'right';
-    case 'right':
-      return 'left';
-  }
-}
-
-// Runner-only input on iOS simulators (simctl io input is not supported).

src/platforms/ios/runner-client.ts

@@ -11,6 +11,7 @@ import net from 'node:net';
 export type RunnerCommand = {
   command:
     | 'tap'
+    | 'longPress'
     | 'type'
     | 'swipe'
     | 'findText'
@@ -27,6 +28,7 @@ export type RunnerCommand = {
   action?: 'get' | 'accept' | 'dismiss';
   x?: number;
   y?: number;
+  durationMs?: number;
   direction?: 'up' | 'down' | 'left' | 'right';
   scale?: number;
   interactiveOnly?: boolean;

src/utils/interactors.ts

@@ -26,6 +26,14 @@ import {
   screenshotIos,
   typeIos,
 } from '../platforms/ios/index.ts';
+import { runIosRunnerCommand } from '../platforms/ios/runner-client.ts';
+
+export type RunnerContext = {
+  appBundleId?: string;
+  verbose?: boolean;
+  logPath?: string;
+  traceLogPath?: string;
+};
 
 export type Interactor = {
   open(app: string, options?: { activity?: string }): Promise<void>;
@@ -41,7 +49,7 @@ export type Interactor = {
   screenshot(outPath: string): Promise<void>;
 };
 
-export function getInteractor(device: DeviceInfo): Interactor {
+export function getInteractor(device: DeviceInfo, runnerContext?: RunnerContext): Interactor {
   switch (device.platform) {
     case 'android':
       return {
@@ -57,7 +65,10 @@ export function getInteractor(device: DeviceInfo): Interactor {
         scrollIntoView: (text) => scrollIntoViewAndroid(device, text),
         screenshot: (outPath) => screenshotAndroid(device, outPath),
       };
-    case 'ios':
+    case 'ios': {
+      if (device.kind === 'simulator' && runnerContext) {
+        return createIosSimulatorInteractor(device, runnerContext);
+      }
       return {
         open: (app) => openIosApp(device, app),
         openDevice: () => openIosDevice(device),
@@ -71,7 +82,101 @@ export function getInteractor(device: DeviceInfo): Interactor {
         scrollIntoView: (text) => scrollIntoViewIos(text),
         screenshot: (outPath) => screenshotIos(device, outPath),
       };
+    }
     default:
       throw new AppError('UNSUPPORTED_PLATFORM', `Unsupported platform: ${device.platform}`);
   }
 }
+
+function createIosSimulatorInteractor(device: DeviceInfo, ctx: RunnerContext): Interactor {
+  const runnerOpts = { verbose: ctx.verbose, logPath: ctx.logPath, traceLogPath: ctx.traceLogPath };
+
+  return {
+    open: (app) => openIosApp(device, app),
+    openDevice: () => openIosDevice(device),
+    close: (app) => closeIosApp(device, app),
+    tap: async (x, y) => {
+      await runIosRunnerCommand(
+        device,
+        { command: 'tap', x, y, appBundleId: ctx.appBundleId },
+        runnerOpts,
+      );
+    },
+    longPress: async (x, y, durationMs) => {
+      await runIosRunnerCommand(
+        device,
+        { command: 'longPress', x, y, durationMs, appBundleId: ctx.appBundleId },
+        runnerOpts,
+      );
+    },
+    focus: async (x, y) => {
+      await runIosRunnerCommand(
+        device,
+        { command: 'tap', x, y, appBundleId: ctx.appBundleId },
+        runnerOpts,
+      );
+    },
+    type: async (text) => {
+      await runIosRunnerCommand(
+        device,
+        { command: 'type', text, appBundleId: ctx.appBundleId },
+        runnerOpts,
+      );
+    },
+    fill: async (x, y, text) => {
+      await runIosRunnerCommand(
+        device,
+        { command: 'tap', x, y, appBundleId: ctx.appBundleId },
+        runnerOpts,
+      );
+      await runIosRunnerCommand(
+        device,
+        { command: 'type', text, clearFirst: true, appBundleId: ctx.appBundleId },
+        runnerOpts,
+      );
+    },
+    scroll: async (direction, _amount) => {
+      if (!['up', 'down', 'left', 'right'].includes(direction)) {
+        throw new AppError('INVALID_ARGS', `Unknown direction: ${direction}`);
+      }
+      const inverted = invertScrollDirection(direction as 'up' | 'down' | 'left' | 'right');
+      await runIosRunnerCommand(
+        device,
+        { command: 'swipe', direction: inverted, appBundleId: ctx.appBundleId },
+        runnerOpts,
+      );
+    },
+    scrollIntoView: async (text) => {
+      const maxAttempts = 8;
+      for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
+        const found = (await runIosRunnerCommand(
+          device,
+          { command: 'findText', text, appBundleId: ctx.appBundleId },
+          runnerOpts,
+        )) as { found?: boolean };
+        if (found?.found) return;
+        await runIosRunnerCommand(
+          device,
+          { command: 'swipe', direction: 'up', appBundleId: ctx.appBundleId },
+          runnerOpts,
+        );
+        await new Promise((resolve) => setTimeout(resolve, 300));
+      }
+      throw new AppError('COMMAND_FAILED', `scrollintoview could not find text: ${text}`);
+    },
+    screenshot: (outPath) => screenshotIos(device, outPath),
+  };
+}
+
+function invertScrollDirection(direction: 'up' | 'down' | 'left' | 'right'): 'up' | 'down' | 'left' | 'right' {
+  switch (direction) {
+    case 'up':
+      return 'down';
+    case 'down':
+      return 'up';
+    case 'left':
+      return 'right';
+    case 'right':
+      return 'left';
+  }
+}