fix(replay): infer iOS app selection without platform

Author: thymikee

src/core/__tests__/dispatch-resolve.test.ts

@@ -185,15 +185,33 @@ test('resolveTargetDevice selects the unique booted simulator with the requested
   );
 });
 
-test('resolveTargetDevice reuses an app-aware selection for later request resolution', async () => {
+test('resolveTargetDevice uses app-aware iOS selection when platform is omitted', async () => {
+  mockListAppleDevices.mockResolvedValue([bootedSimulator, secondBootedSimulator]);
+  mockFindIosSimulatorInstalledApp.mockImplementation(async (device) =>
+    device.id === secondBootedSimulator.id ? 'com.example.demo' : undefined,
+  );
+
+  const result = await resolveTargetDevice({}, { appleSimulatorAppTarget: 'com.example.demo' });
+
+  assert.equal(result.id, secondBootedSimulator.id);
+  assert.deepEqual(
+    mockFindIosSimulatorInstalledApp.mock.calls.map(([device, app]) => [device.id, app]),
+    [
+      [bootedSimulator.id, 'com.example.demo'],
+      [secondBootedSimulator.id, 'com.example.demo'],
+    ],
+  );
+});
+
+test('resolveTargetDevice reuses an app-aware selection for later platform-inferred resolution', async () => {
   mockListAppleDevices.mockResolvedValue([bootedSimulator, secondBootedSimulator]);
   mockFindIosSimulatorInstalledApp.mockImplementation(async (device) =>
     device.id === secondBootedSimulator.id ? 'com.example.demo' : undefined,
   );
 
   const [appAware, laterResolution] = await withResolveTargetDeviceCacheScope(async () => [
-    await resolveTargetDevice({ platform: 'ios' }, { appleSimulatorAppTarget: 'com.example.demo' }),
-    await resolveTargetDevice({ platform: 'ios' }),
+    await resolveTargetDevice({}, { appleSimulatorAppTarget: 'com.example.demo' }),
+    await resolveTargetDevice({}),
   ]);
 
   assert.equal(appAware.id, secondBootedSimulator.id);
@@ -233,11 +251,11 @@ test('resolveTargetDevice refuses ambiguous booted simulator app matches', async
   assert.equal(error.details?.hint, 'Pass --udid to select the intended simulator explicitly.');
 });
 
-test('resolveTargetDevice does not probe when an Apple device is explicitly selected', async () => {
+test('resolveTargetDevice preserves an explicit device selector when platform is omitted', async () => {
   mockListAppleDevices.mockResolvedValue([bootedSimulator, secondBootedSimulator]);
 
   const result = await resolveTargetDevice(
-    { platform: 'ios', udid: bootedSimulator.id },
+    { udid: bootedSimulator.id },
     { appleSimulatorAppTarget: 'com.example.demo' },
   );
 

src/core/dispatch-resolve.ts

@@ -214,7 +214,7 @@ export async function resolveTargetDevice(
       }
       const injectedDevices = await readInjectedDeviceInventory(inventoryRequest);
       if (injectedDevices) {
-        if (isAppleResolutionSelector(selector)) {
+        if (shouldUseAppleResolution(selector, options)) {
           return cacheResolvedTargetDevice(
             cacheKey,
             await resolveAppleDevice(injectedDevices, selector as AppleDeviceSelector, {
@@ -232,7 +232,7 @@ export async function resolveTargetDevice(
 
       const devices = await listLocalDeviceInventory(inventoryRequest);
 
-      if (isAppleResolutionSelector(selector)) {
+      if (shouldUseAppleResolution(selector, options)) {
         return cacheResolvedTargetDevice(
           cacheKey,
           await resolveAppleDevice(devices, selector as AppleDeviceSelector, {
@@ -328,6 +328,14 @@ function isAppleResolutionSelector(selector: {
   return isApplePlatform(selector.platform);
 }
 
+function shouldUseAppleResolution(
+  selector: { platform?: PlatformSelector; target?: DeviceTarget },
+  options: ResolveTargetDeviceOptions,
+): boolean {
+  if (isAppleResolutionSelector(selector)) return true;
+  return selector.platform === undefined && options.appleSimulatorAppTarget !== undefined;
+}
+
 function readResolveTargetDeviceCache(cacheKey: string): DeviceInfo | undefined {
   const cache = resolveTargetDeviceCacheScope.getStore();
   const cached = cache?.get(cacheKey);

src/daemon/__tests__/request-router-open.test.ts

@@ -143,7 +143,7 @@ test('fresh replay reserves its authored app simulator before any replay step',
       session: 'fresh-replay',
       command: 'replay',
       positionals: [replayPath],
-      flags: { platform: 'ios' },
+      flags: {},
       meta: { cwd: root },
     },
     sessionName: 'fresh-replay',
@@ -152,7 +152,7 @@ test('fresh replay reserves its authored app simulator before any replay step',
 
   expect(keys).toEqual(['session:fresh-replay', 'device:SIM-WITH-APP']);
   expect(mockResolveTargetDevice).toHaveBeenCalledWith(
-    { platform: 'ios' },
+    {},
     { appleSimulatorAppTarget: 'com.example.demo' },
   );
 });

src/daemon/handlers/__tests__/session-replay-runtime-plan.test.ts

@@ -410,7 +410,7 @@ test('fresh typed Maestro replay resolves its configured app before runtime defa
   const response = await runReplayScriptFile({
     req: baseReq({
       positionals: [flowPath],
-      flags: { replayBackend: 'maestro', platform: 'ios' },
+      flags: { replayBackend: 'maestro' },
       runtime: { metroPort: 8081 },
     }),
     sessionName: 'default',
@@ -421,7 +421,7 @@ test('fresh typed Maestro replay resolves its configured app before runtime defa
 
   expect(response.ok).toBe(true);
   expect(mockResolveTargetDevice).toHaveBeenCalledWith(
-    { replayBackend: 'maestro', platform: 'ios' },
+    { replayBackend: 'maestro' },
     { appleSimulatorAppTarget: 'com.example.demo' },
   );
   expect(invoke).toHaveBeenCalledWith(

src/daemon/handlers/session-replay-maestro-runtime.ts

@@ -214,7 +214,10 @@ async function resolveMaestroReplayBinding(params: {
     session?.device ??
     (requestedPlatform === 'android' || requestedPlatform === 'ios'
       ? undefined
-      : await resolveTargetDevice(req.flags ?? {}));
+      : await resolveTargetDevice(
+          req.flags ?? {},
+          buildMaestroReplayTargetDeviceResolutionOptions(program),
+        ));
   const platform = resolveMaestroPlatform(req, device);
   const runtimeHints = resolveEffectiveOpenRuntimeHints({
     req,