fix: resolve ios simulator url open targets

Author: thymikee

src/compat/maestro/__tests__/runtime-targets.test.ts

@@ -59,6 +59,42 @@ test('resolveMaestroNodeFromSnapshot blocks taps on app content behind React Nat
   });
 });
 
+test('resolveVisibleMaestroNodeFromSnapshot does not block content behind collapsed React Native warnings', () => {
+  const snapshot: SnapshotState = {
+    createdAt: Date.now(),
+    nodes: [
+      {
+        index: 1,
+        ref: 'e1',
+        type: 'android.widget.TextView',
+        label: 'Morning Favorites',
+        rect: { x: 24, y: 420, width: 320, height: 54 },
+        depth: 8,
+      },
+      {
+        index: 2,
+        ref: 'e2',
+        type: 'android.view.ViewGroup',
+        label: 'Open debugger to view warnings',
+        rect: { x: 0, y: 2190, width: 1080, height: 96 },
+        depth: 6,
+      },
+    ],
+  };
+
+  const appContent = resolveVisibleMaestroNodeFromSnapshot(
+    snapshot,
+    'label="Morning Favorites" || text="Morning Favorites" || id="Morning Favorites"',
+    'android',
+    { referenceWidth: 1080, referenceHeight: 2340 },
+  );
+
+  expect(appContent).toMatchObject({
+    ok: true,
+    node: expect.objectContaining({ label: 'Morning Favorites' }),
+  });
+});
+
 test('resolveMaestroNodeFromSnapshot prefers foreground duplicate matches', () => {
   const snapshot: SnapshotState = {
     createdAt: Date.now(),

src/compat/maestro/runtime-targets.ts

@@ -184,6 +184,9 @@ function filterReactNativeOverlayBlockedMatches(
   if (!overlay.detected) {
     return { matches, blockedByReactNativeOverlay: false };
   }
+  if (!overlay.redBox) {
+    return { matches, blockedByReactNativeOverlay: false };
+  }
   const overlayNodeIndexes = new Set(
     [...overlay.dismissNodes, ...overlay.minimizeNodes, ...overlay.collapsedNodes].map(
       (node) => node.index,

src/daemon/handlers/__tests__/session.test.ts

@@ -64,6 +64,7 @@ vi.mock('../../../platforms/ios/apps.ts', async (importOriginal) => {
     ...actual,
     listIosApps: vi.fn(async () => []),
     resolveIosApp: vi.fn(async () => undefined),
+    resolveIosSimulatorDeepLinkBundleId: vi.fn(async () => undefined),
   };
 });
 vi.mock('../../app-log.ts', async (importOriginal) => {
@@ -108,7 +109,7 @@ import {
   ensureAndroidEmulatorBooted,
 } from '../../../platforms/android/devices.ts';
 import { listAppleDevices } from '../../../platforms/ios/devices.ts';
-import { resolveIosApp } from '../../../platforms/ios/apps.ts';
+import { resolveIosApp, resolveIosSimulatorDeepLinkBundleId } from '../../../platforms/ios/apps.ts';
 import { startAppLog, stopAppLog } from '../../app-log.ts';
 import { defaultInstallOps, defaultReinstallOps } from '../session-deploy.ts';
 import { clearRequestCanceled, markRequestCanceled } from '../../request-cancel.ts';
@@ -129,6 +130,7 @@ const mockRunCmd = vi.mocked(runCmd);
 const mockListAndroidDevices = vi.mocked(listAndroidDevices);
 const mockListAppleDevices = vi.mocked(listAppleDevices);
 const mockResolveIosApp = vi.mocked(resolveIosApp);
+const mockResolveIosSimulatorDeepLinkBundleId = vi.mocked(resolveIosSimulatorDeepLinkBundleId);
 const mockEnsureAndroidEmulatorBooted = vi.mocked(ensureAndroidEmulatorBooted);
 const mockStartAppLog = vi.mocked(startAppLog);
 const mockStopAppLog = vi.mocked(stopAppLog);
@@ -177,6 +179,8 @@ beforeEach(() => {
     }
     return app.includes('.') ? app : `com.example.${normalizedApp}`;
   });
+  mockResolveIosSimulatorDeepLinkBundleId.mockReset();
+  mockResolveIosSimulatorDeepLinkBundleId.mockResolvedValue(undefined);
   mockEnsureAndroidEmulatorBooted.mockReset();
   mockStartAppLog.mockReset();
   mockStopAppLog.mockReset();
@@ -1865,6 +1869,102 @@ test('open URL on existing iOS device session preserves app bundle id context',
   expect(dispatchedContext?.appBundleId).toBe('com.example.app');
 });
 
+test('open custom URL on existing iOS simulator session preserves app bundle id context', async () => {
+  const sessionStore = makeSessionStore();
+  const sessionName = 'ios-simulator-session';
+  sessionStore.set(sessionName, {
+    ...makeSession(sessionName, {
+      platform: 'ios',
+      id: 'sim-1',
+      name: 'iPhone 17 Pro',
+      kind: 'simulator',
+      booted: true,
+    }),
+    appBundleId: 'com.example.app',
+    appName: 'Example App',
+  });
+  mockResolveTargetDevice.mockResolvedValue({
+    platform: 'ios',
+    id: 'sim-1',
+    name: 'iPhone 17 Pro',
+    kind: 'simulator',
+    booted: true,
+  });
+
+  let dispatchedContext: Record<string, unknown> | undefined;
+  mockDispatch.mockImplementation(async (_device, _command, _positionals, _out, context) => {
+    dispatchedContext = context as Record<string, unknown> | undefined;
+    return {};
+  });
+
+  const response = await handleSessionCommands({
+    req: {
+      token: 't',
+      session: sessionName,
+      command: 'open',
+      positionals: ['myapp://item/42'],
+      flags: {},
+    },
+    sessionName,
+    logPath: path.join(os.tmpdir(), 'daemon.log'),
+    sessionStore,
+    invoke: noopInvoke,
+  });
+
+  expect(response).toBeTruthy();
+  expect(response?.ok).toBe(true);
+  const updated = sessionStore.get(sessionName);
+  expect(updated?.appBundleId).toBe('com.example.app');
+  expect(updated?.appName).toBe('myapp://item/42');
+  expect(dispatchedContext?.appBundleId).toBe('com.example.app');
+});
+
+test('open custom URL on fresh iOS simulator session infers app bundle id from URL scheme', async () => {
+  const sessionStore = makeSessionStore();
+  const sessionName = 'ios-simulator-url-session';
+  mockResolveTargetDevice.mockResolvedValue({
+    platform: 'ios',
+    id: 'sim-1',
+    name: 'iPhone 17 Pro',
+    kind: 'simulator',
+    booted: true,
+  });
+  mockResolveIosSimulatorDeepLinkBundleId.mockResolvedValue('org.reactnavigation.playground');
+
+  let dispatchedContext: Record<string, unknown> | undefined;
+  mockDispatch.mockImplementation(async (_device, _command, _positionals, _out, context) => {
+    dispatchedContext = context as Record<string, unknown> | undefined;
+    return {};
+  });
+
+  const response = await handleSessionCommands({
+    req: {
+      token: 't',
+      session: sessionName,
+      command: 'open',
+      positionals: ['rne://navigator-layout'],
+      flags: { platform: 'ios', udid: 'sim-1' },
+    },
+    sessionName,
+    logPath: path.join(os.tmpdir(), 'daemon.log'),
+    sessionStore,
+    invoke: noopInvoke,
+  });
+
+  expect(response).toBeTruthy();
+  expect(response?.ok).toBe(true);
+  expect(mockResolveIosSimulatorDeepLinkBundleId).toHaveBeenCalledWith(
+    expect.objectContaining({ id: 'sim-1', kind: 'simulator' }),
+    'rne://navigator-layout',
+  );
+  const updated = sessionStore.get(sessionName);
+  expect(updated?.appBundleId).toBe('org.reactnavigation.playground');
+  expect(updated?.appName).toBe('rne://navigator-layout');
+  expect(dispatchedContext?.appBundleId).toBe('org.reactnavigation.playground');
+  expect(mockPrewarmIosRunnerSession).toHaveBeenCalledTimes(1);
+  expect(mockPrewarmIosRunnerXctestrun).not.toHaveBeenCalled();
+});
+
 test('open iOS app session prewarms runner session when app bundle id is known', async () => {
   const sessionStore = makeSessionStore();
   const sessionName = 'ios-device-session';
@@ -1904,7 +2004,7 @@ test('open iOS app session prewarms runner session when app bundle id is known',
   expect(mockPrewarmIosRunnerXctestrun).not.toHaveBeenCalled();
 });
 
-test('open iOS URL without app bundle id keeps xctestrun-only prewarm', async () => {
+test('open iOS URL without app bundle id skips runner prewarm', async () => {
   const sessionStore = makeSessionStore();
   const sessionName = 'ios-device-session';
   sessionStore.set(
@@ -1935,7 +2035,7 @@ test('open iOS URL without app bundle id keeps xctestrun-only prewarm', async ()
   expect(response).toBeTruthy();
   expect(response?.ok).toBe(true);
   expect(mockPrewarmIosRunnerSession).not.toHaveBeenCalled();
-  expect(mockPrewarmIosRunnerXctestrun).toHaveBeenCalledTimes(1);
+  expect(mockPrewarmIosRunnerXctestrun).not.toHaveBeenCalled();
 });
 
 test('open web URL on iOS device session without active app falls back to Safari', async () => {

src/daemon/handlers/session-open-target.ts

@@ -1,4 +1,8 @@
-import { isDeepLinkTarget, resolveIosDeviceDeepLinkBundleId } from '../../core/open-target.ts';
+import {
+  isDeepLinkTarget,
+  isWebUrl,
+  resolveIosDeviceDeepLinkBundleId,
+} from '../../core/open-target.ts';
 import type { DeviceInfo } from '../../utils/device.ts';
 
 async function resolveIosBundleIdForOpen(
@@ -12,11 +16,28 @@ async function resolveIosBundleIdForOpen(
     if (device.kind === 'device') {
       return resolveIosDeviceDeepLinkBundleId(currentAppBundleId, openTarget);
     }
+    if (!isWebUrl(openTarget)) {
+      return (
+        currentAppBundleId ?? (await tryResolveIosSimulatorDeepLinkBundleId(device, openTarget))
+      );
+    }
     return undefined;
   }
   return await tryResolveIosAppBundleId(device, openTarget);
 }
 
+async function tryResolveIosSimulatorDeepLinkBundleId(
+  device: DeviceInfo,
+  openTarget: string,
+): Promise<string | undefined> {
+  try {
+    const { resolveIosSimulatorDeepLinkBundleId } = await import('../../platforms/ios/apps.ts');
+    return await resolveIosSimulatorDeepLinkBundleId(device, openTarget);
+  } catch {
+    return undefined;
+  }
+}
+
 async function tryResolveIosAppBundleId(
   device: DeviceInfo,
   openTarget: string,

src/daemon/handlers/session-open.ts

@@ -5,7 +5,6 @@ import { contextFromFlags } from '../context.ts';
 import { createRequestCanceledError, isRequestCanceled } from '../request-cancel.ts';
 import {
   prewarmIosRunnerSession,
-  prewarmIosRunnerXctestrun,
   stopIosRunnerSession,
 } from '../../platforms/ios/runner-client.ts';
 import { applyRuntimeHintsToApp } from '../runtime-hints.ts';
@@ -183,10 +182,6 @@ async function completeOpenCommand(params: {
     timing.runnerPrewarmKind = 'session';
     timing.runnerPrewarmScheduled = true;
     runnerPrewarm = prewarmIosRunnerSession(device, runnerPrewarmOptions);
-  } else if (shouldPrewarmIosRunner) {
-    timing.runnerPrewarmKind = 'xctestrun';
-    timing.runnerPrewarmScheduled = true;
-    runnerPrewarm = prewarmIosRunnerXctestrun(device, runnerPrewarmOptions);
   }
   const openStartedAtMs = Date.now();
   await dispatchCommand(device, 'open', openPositionals, req.flags?.out, {

src/platforms/ios/__tests__/index.test.ts

@@ -52,6 +52,7 @@ import {
   readIosClipboardText,
   reinstallIosApp,
   resolveIosApp,
+  resolveIosSimulatorDeepLinkBundleId,
   screenshotIos,
   setIosSetting,
   shouldFallbackToRunnerForIosScreenshot,
@@ -1640,6 +1641,76 @@ test('resolveIosApp caches display-name bundle matches but bypasses exact bundle
   }
 });
 
+test('resolveIosSimulatorDeepLinkBundleId maps custom URL scheme to installed user app', async () => {
+  const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'agent-device-ios-scheme-resolve-'));
+  const xcrunPath = path.join(tmpDir, 'xcrun');
+  const plutilPath = path.join(tmpDir, 'plutil');
+  const appPath = path.join(tmpDir, 'ReactNavigationExample.app');
+  const runnerPath = path.join(tmpDir, 'AgentDeviceRunner.app');
+  await fs.writeFile(
+    xcrunPath,
+    [
+      '#!/bin/sh',
+      'if [ "$1" = "simctl" ] && [ "$2" = "listapps" ]; then',
+      "  cat <<'JSON'",
+      JSON.stringify({
+        'com.callstack.agentdevice.runner': {
+          ApplicationType: 'User',
+          CFBundleDisplayName: 'AgentDeviceRunner',
+          Path: runnerPath,
+        },
+        'org.reactnavigation.playground': {
+          ApplicationType: 'User',
+          CFBundleDisplayName: 'React Navigation Example',
+          Path: appPath,
+        },
+      }),
+      'JSON',
+      '  exit 0',
+      'fi',
+      'exit 1',
+      '',
+    ].join('\n'),
+    'utf8',
+  );
+  await fs.writeFile(
+    plutilPath,
+    [
+      '#!/bin/sh',
+      'case "$5" in',
+      [
+        '  *AgentDeviceRunner.app/Info.plist) echo ',
+        '\'{"CFBundleURLTypes":[{"CFBundleURLSchemes":["rne"]}]}\' ;;',
+      ].join(''),
+      [
+        '  *ReactNavigationExample.app/Info.plist) echo ',
+        '\'{"CFBundleURLTypes":[{"CFBundleURLSchemes":["rne"]}]}\' ;;',
+      ].join(''),
+      '  *) echo "{}" ;;',
+      'esac',
+      'exit 0',
+      '',
+    ].join('\n'),
+    'utf8',
+  );
+  await fs.chmod(xcrunPath, 0o755);
+  await fs.chmod(plutilPath, 0o755);
+
+  const previousPath = process.env.PATH;
+  process.env.PATH = `${tmpDir}${path.delimiter}${previousPath ?? ''}`;
+
+  try {
+    const bundleId = await resolveIosSimulatorDeepLinkBundleId(
+      IOS_TEST_SIMULATOR,
+      'rne://navigator-layout',
+    );
+    assert.equal(bundleId, 'org.reactnavigation.playground');
+  } finally {
+    process.env.PATH = previousPath;
+    await fs.rm(tmpDir, { recursive: true, force: true });
+  }
+});
+
 test('installIosInstallablePath invalidates cached display-name bundle matches', async () => {
   const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'agent-device-ios-install-cache-'));
   const xcrunPath = path.join(tmpDir, 'xcrun');