fix: ios press idle timeout (#543)

* fix: ios press idle timeout

* fix: preserve ios mutating command recovery

---------

Co-authored-by: Michał Pierzchała <thymikee@gmail.com>

Author: demchenkoalex

ios-runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerTests+Lifecycle.swift

@@ -109,18 +109,53 @@ extension RunnerTests {
     operation: () -> Void
   ) {
     let setter = NSSelectorFromString("setWaitForIdleTimeout:")
-    guard target.responds(to: setter) else {
-      operation()
-      return
+    let supportsWaitForIdleTimeout = target.responds(to: setter)
+    let previous = supportsWaitForIdleTimeout
+      ? (target.value(forKey: "waitForIdleTimeout") as? NSNumber)
+      : nil
+    if supportsWaitForIdleTimeout {
+      target.setValue(resolveScrollInteractionIdleTimeout(), forKey: "waitForIdleTimeout")
     }
-    let previous = target.value(forKey: "waitForIdleTimeout") as? NSNumber
-    target.setValue(resolveScrollInteractionIdleTimeout(), forKey: "waitForIdleTimeout")
     defer {
       if let previous {
         target.setValue(previous.doubleValue, forKey: "waitForIdleTimeout")
       }
     }
-    operation()
+    performWithQuiescenceSkippedIfSupported(target, operation: operation)
+  }
+
+  // Some apps never report post-gesture quiescence, even after XCTest has synthesized the event.
+  private func performWithQuiescenceSkippedIfSupported(
+    _ target: XCUIApplication,
+    operation: () -> Void
+  ) {
+    let selector = NSSelectorFromString("_performWithInteractionOptions:block:")
+    guard target.responds(to: selector) else {
+      operation()
+      return
+    }
+    typealias PerformWithInteractionOptions = @convention(c) (
+      NSObject,
+      Selector,
+      UInt,
+      @convention(block) () -> Void
+    ) -> Void
+    let implementation = target.method(for: selector)
+    let performWithOptions = unsafeBitCast(
+      implementation,
+      to: PerformWithInteractionOptions.self
+    )
+    let skipPreEventQuiescence = UInt(1)
+    let skipPostEventQuiescence = UInt(2)
+    withoutActuallyEscaping(operation) { escapableOperation in
+      let block: @convention(block) () -> Void = escapableOperation
+      performWithOptions(
+        target,
+        selector,
+        skipPreEventQuiescence | skipPostEventQuiescence,
+        block
+      )
+    }
   }
 
   private func resolveScrollInteractionIdleTimeout() -> TimeInterval {

src/platforms/ios/__tests__/runner-command-retry.test.ts

@@ -0,0 +1,81 @@
+import { beforeEach, test, vi } from 'vitest';
+import assert from 'node:assert/strict';
+import { IOS_SIMULATOR } from '../../../__tests__/test-utils/index.ts';
+import { AppError } from '../../../utils/errors.ts';
+import type { RunnerSession } from '../runner-session-types.ts';
+
+const { mockEnsureRunnerSession, mockExecuteRunnerCommandWithSession, mockStopRunnerSession } =
+  vi.hoisted(() => ({
+    mockEnsureRunnerSession: vi.fn(),
+    mockExecuteRunnerCommandWithSession: vi.fn(),
+    mockStopRunnerSession: vi.fn(),
+  }));
+
+vi.mock('../runner-session.ts', async () => {
+  const actual =
+    await vi.importActual<typeof import('../runner-session.ts')>('../runner-session.ts');
+  return {
+    ...actual,
+    ensureRunnerSession: mockEnsureRunnerSession,
+    executeRunnerCommandWithSession: mockExecuteRunnerCommandWithSession,
+    stopRunnerSession: mockStopRunnerSession,
+  };
+});
+
+import { runIosRunnerCommand } from '../runner-client.ts';
+
+beforeEach(() => {
+  vi.resetAllMocks();
+});
+
+test('mutating commands restart stale ready sessions when the preflight probe never reaches the runner', async () => {
+  const staleSession = makeRunnerSession({ port: 8100, ready: true });
+  const freshSession = makeRunnerSession({ port: 8101, ready: false });
+
+  mockEnsureRunnerSession.mockResolvedValueOnce(staleSession).mockResolvedValueOnce(freshSession);
+  mockExecuteRunnerCommandWithSession
+    .mockRejectedValueOnce(new AppError('COMMAND_FAILED', 'Runner did not accept connection'))
+    .mockResolvedValueOnce({ message: 'tapped' });
+
+  const result = await runIosRunnerCommand(IOS_SIMULATOR, { command: 'tap', x: 120, y: 240 });
+
+  assert.deepEqual(result, { message: 'tapped' });
+  assert.equal(mockEnsureRunnerSession.mock.calls.length, 2);
+  assert.equal(mockStopRunnerSession.mock.calls.length, 1);
+  assert.equal(mockStopRunnerSession.mock.calls[0]?.[0], staleSession);
+  assert.equal(mockExecuteRunnerCommandWithSession.mock.calls.length, 2);
+  assert.equal(mockExecuteRunnerCommandWithSession.mock.calls[0]?.[2].command, 'tap');
+  assert.equal(mockExecuteRunnerCommandWithSession.mock.calls[1]?.[1], freshSession);
+});
+
+test('mutating commands do not restart or replay after command send failure', async () => {
+  const session = makeRunnerSession({ port: 8100, ready: true });
+
+  mockEnsureRunnerSession.mockResolvedValueOnce(session);
+  mockExecuteRunnerCommandWithSession.mockRejectedValueOnce(
+    new Error('request timed out after reaching runner'),
+  );
+
+  await assert.rejects(() =>
+    runIosRunnerCommand(IOS_SIMULATOR, { command: 'tap', x: 120, y: 240 }),
+  );
+
+  assert.equal(mockEnsureRunnerSession.mock.calls.length, 1);
+  assert.equal(mockStopRunnerSession.mock.calls.length, 0);
+  assert.equal(mockExecuteRunnerCommandWithSession.mock.calls.length, 1);
+});
+
+function makeRunnerSession(overrides: Partial<RunnerSession> = {}): RunnerSession {
+  return {
+    sessionId: `session-${overrides.port ?? 8100}`,
+    device: IOS_SIMULATOR,
+    deviceId: IOS_SIMULATOR.id,
+    port: 8100,
+    xctestrunPath: '/tmp/runner.xctestrun',
+    jsonPath: '/tmp/runner.json',
+    testPromise: Promise.resolve({ exitCode: 0, stdout: '', stderr: '' }),
+    child: { pid: 1234, exitCode: null },
+    ready: true,
+    ...overrides,
+  } as RunnerSession;
+}

src/platforms/ios/__tests__/runner-transport.test.ts

@@ -17,7 +17,11 @@ vi.mock('../../../utils/exec.ts', async () => {
   };
 });
 
-import { clearDeviceTunnelIpCache, waitForRunner } from '../runner-transport.ts';
+import {
+  clearDeviceTunnelIpCache,
+  sendRunnerCommandOnce,
+  waitForRunner,
+} from '../runner-transport.ts';
 
 const iosSimulator: DeviceInfo = {
   platform: 'ios',
@@ -144,6 +148,22 @@ test('waitForRunner invalidates cached tunnel IP when localhost fallback succeed
   ]);
 });
 
+test('sendRunnerCommandOnce does not retry or simulator fallback after request failure', async () => {
+  vi.stubGlobal(
+    'fetch',
+    vi.fn(async () => {
+      throw new Error('request timed out after reaching runner');
+    }),
+  );
+
+  await assert.rejects(() =>
+    sendRunnerCommandOnce(iosSimulator, 8100, { command: 'tap', x: 120, y: 240 }, 5_000),
+  );
+
+  assert.equal(vi.mocked(fetch).mock.calls.length, 1);
+  assert.equal(mockRunCmd.mock.calls.length, 0);
+});
+
 function stubSuccessfulFetch(): void {
   vi.stubGlobal(
     'fetch',

src/platforms/ios/runner-client.ts

@@ -2,19 +2,14 @@ import { AppError } from '../../utils/errors.ts';
 import { withRetry } from '../../utils/retry.ts';
 import type { DeviceInfo } from '../../utils/device.ts';
 import { getRequestSignal } from '../../daemon/request-cancel.ts';
-import {
-  waitForRunner,
-  RUNNER_COMMAND_TIMEOUT_MS,
-  RUNNER_STARTUP_TIMEOUT_MS,
-} from './runner-transport.ts';
+import { RUNNER_COMMAND_TIMEOUT_MS, RUNNER_STARTUP_TIMEOUT_MS } from './runner-transport.ts';
 import {
   type RunnerSession,
   ensureRunnerSession,
   stopRunnerSession,
   stopIosRunnerSession,
   validateRunnerDevice,
   executeRunnerCommandWithSession,
-  parseRunnerResponse,
 } from './runner-session.ts';
 import {
   assertRunnerRequestActive,
@@ -95,16 +90,14 @@ async function executeRunnerCommand(
         await stopIosRunnerSession(device.id);
       }
       session = await ensureRunnerSession(device, options);
-      const response = await waitForRunner(
-        session.device,
-        session.port,
+      return await executeRunnerCommandWithSession(
+        device,
+        session,
         command,
         options.logPath,
         RUNNER_STARTUP_TIMEOUT_MS,
-        undefined,
         signal,
       );
-      return await parseRunnerResponse(response, session, options.logPath);
     }
     throw err;
   }

src/platforms/ios/runner-session.ts

@@ -6,11 +6,13 @@ import {
   type ExecBackgroundResult,
 } from '../../utils/exec.ts';
 import { withKeyedLock } from '../../utils/keyed-lock.ts';
+import { Deadline } from '../../utils/retry.ts';
 import { isProcessAlive, isProcessGroupAlive } from '../../utils/process-identity.ts';
 import type { DeviceInfo } from '../../utils/device.ts';
 import { buildSimctlArgsForDevice } from './simctl.ts';
 import {
   waitForRunner,
+  sendRunnerCommandOnce,
   getFreePort,
   logChunk,
   cleanupTempFile,
@@ -26,7 +28,7 @@ import {
   resolveRunnerMaxConcurrentDestinationsFlag,
   runnerPrepProcesses,
 } from './runner-xctestrun.ts';
-import type { RunnerCommand } from './runner-contract.ts';
+import { isReadOnlyRunnerCommand, type RunnerCommand } from './runner-contract.ts';
 import type { RunnerSession } from './runner-session-types.ts';
 
 export type { RunnerSession } from './runner-session-types.ts';
@@ -334,15 +336,36 @@ export async function executeRunnerCommandWithSession(
   timeoutMs: number,
   signal?: AbortSignal,
 ): Promise<Record<string, unknown>> {
-  const response = await waitForRunner(
+  const readOnlyCommand = isReadOnlyRunnerCommand(command.command);
+  if (readOnlyCommand) {
+    const response = await waitForRunner(
+      device,
+      session.port,
+      command,
+      logPath,
+      timeoutMs,
+      session,
+      signal,
+    );
+    return await parseRunnerResponse(response, session, logPath);
+  }
+
+  const deadline = Deadline.fromTimeoutMs(timeoutMs);
+  const readinessResponse = await waitForRunner(
     device,
     session.port,
-    command,
+    { command: 'uptime' },
     logPath,
-    timeoutMs,
+    Math.min(RUNNER_STARTUP_TIMEOUT_MS, deadline.remainingMs()),
     session,
     signal,
   );
+  await parseRunnerResponse(readinessResponse, session, logPath);
+  const remainingMs = deadline.remainingMs();
+  if (remainingMs <= 0) {
+    throw new AppError('COMMAND_FAILED', 'Runner command deadline exceeded', { timeoutMs });
+  }
+  const response = await sendRunnerCommandOnce(device, session.port, command, remainingMs, signal);
   return await parseRunnerResponse(response, session, logPath);
 }
 

src/platforms/ios/runner-transport.ts

@@ -77,22 +77,7 @@ export async function waitForRunner(
   signal?: AbortSignal,
 ): Promise<Response> {
   const deadline = Deadline.fromTimeoutMs(timeoutMs);
-  let requestTunnelIp: string | null | undefined;
-  const getEndpoints = async (timeoutBudgetMs?: number, forceRefresh = false) => {
-    const tunnelIp = await getDeviceTunnelIpForRequest({
-      device,
-      timeoutBudgetMs,
-      forceRefresh,
-      requestTunnelIp,
-      setRequestTunnelIp: (ip) => {
-        requestTunnelIp = ip;
-      },
-    });
-    return {
-      endpoints: resolveRunnerCommandEndpoints(device, port, tunnelIp.ip),
-      cached: tunnelIp.sharedCacheHit,
-    };
-  };
+  const { getEndpoints } = createRunnerEndpointResolver(device, port);
   let { endpoints } = await getEndpoints(deadline.remainingMs());
   let lastError: unknown = null;
   const maxAttempts = Math.max(1, Math.ceil(timeoutMs / RUNNER_CONNECT_ATTEMPT_INTERVAL_MS));
@@ -188,6 +173,63 @@ export async function waitForRunner(
   throw buildRunnerConnectError({ port, endpoints, logPath, lastError });
 }
 
+export async function sendRunnerCommandOnce(
+  device: DeviceInfo,
+  port: number,
+  command: RunnerCommand,
+  timeoutMs: number = RUNNER_COMMAND_TIMEOUT_MS,
+  signal?: AbortSignal,
+): Promise<Response> {
+  if (signal?.aborted) {
+    throw createRequestCanceledError();
+  }
+  const deadline = Deadline.fromTimeoutMs(timeoutMs);
+  const { getEndpoints } = createRunnerEndpointResolver(device, port);
+  const { endpoints } = await getEndpoints(deadline.remainingMs());
+  const endpoint = endpoints[0];
+  if (!endpoint) {
+    throw new AppError('COMMAND_FAILED', 'Runner command endpoint not available', {
+      port,
+      endpoints,
+    });
+  }
+  const remainingMs = deadline.remainingMs();
+  if (remainingMs <= 0) {
+    throw new AppError('COMMAND_FAILED', 'Runner command deadline exceeded', { timeoutMs });
+  }
+  return await fetchWithTimeout(
+    endpoint,
+    {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(command),
+    },
+    remainingMs,
+    signal,
+  );
+}
+
+function createRunnerEndpointResolver(device: DeviceInfo, port: number) {
+  let requestTunnelIp: string | null | undefined;
+  return {
+    getEndpoints: async (timeoutBudgetMs?: number, forceRefresh = false) => {
+      const tunnelIp = await getDeviceTunnelIpForRequest({
+        device,
+        timeoutBudgetMs,
+        forceRefresh,
+        requestTunnelIp,
+        setRequestTunnelIp: (ip) => {
+          requestTunnelIp = ip;
+        },
+      });
+      return {
+        endpoints: resolveRunnerCommandEndpoints(device, port, tunnelIp.ip),
+        cached: tunnelIp.sharedCacheHit,
+      };
+    },
+  };
+}
+
 async function tryRunnerEndpoints(
   endpoints: string[],
   params: {