fix(replay): preserve authored Android selection

Author: thymikee

src/daemon/__tests__/replay-device-selection.test.ts

@@ -2,15 +2,15 @@ import { test, expect } from 'vitest';
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
-import { buildReplayTargetDeviceResolutionOptions } from '../replay-device-selection.ts';
+import { buildReplayTargetDeviceResolution } from '../replay-device-selection.ts';
 
 test('replay leaves deep-link opens to normal device resolution', () => {
   const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agent-device-replay-device-selection-'));
   const replayPath = path.join(root, 'deep-link.ad');
   fs.writeFileSync(replayPath, 'open demo://checkout\n');
 
   expect(
-    buildReplayTargetDeviceResolutionOptions({
+    buildReplayTargetDeviceResolution({
       token: 'test-token',
       session: 'default',
       command: 'replay',
@@ -19,3 +19,22 @@ test('replay leaves deep-link opens to normal device resolution', () => {
     }),
   ).toBeUndefined();
 });
+
+test('native replay uses its authored Android runtime setting without an iOS app probe', () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agent-device-replay-device-selection-'));
+  const replayPath = path.join(root, 'android.ad');
+  fs.writeFileSync(
+    replayPath,
+    'runtime set --platform android --metro-port 8081\nopen com.example.demo\n',
+  );
+
+  expect(
+    buildReplayTargetDeviceResolution({
+      token: 'test-token',
+      session: 'default',
+      command: 'replay',
+      positionals: [replayPath],
+      meta: { cwd: root },
+    }),
+  ).toEqual({ flags: { platform: 'android' }, options: undefined });
+});

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

@@ -30,6 +30,17 @@ function makeIosDevice(id: string): DeviceInfo {
   };
 }
 
+function makeAndroidDevice(id: string): DeviceInfo {
+  return {
+    platform: 'android',
+    id,
+    name: `Android ${id}`,
+    kind: 'emulator',
+    target: 'mobile',
+    booted: true,
+  };
+}
+
 function createOpenHandler(
   sessionStore: ReturnType<typeof makeSessionStore>,
   leaseRegistry = new LeaseRegistry(),
@@ -152,11 +163,39 @@ 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' },
   );
 });
 
+test('fresh replay preserves an authored Android platform before advisory locking', async () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agent-device-replay-android-lock-'));
+  const replayPath = path.join(root, 'flow.ad');
+  fs.writeFileSync(
+    replayPath,
+    'runtime set --platform android --metro-port 8081\nopen com.example.demo\n',
+  );
+  const sessionStore = makeSessionStore('agent-device-router-replay-android-lock-');
+  const androidDevice = makeAndroidDevice('ANDROID-EMULATOR');
+  mockResolveTargetDevice.mockResolvedValue(androidDevice);
+
+  const keys = await resolveRequestExecutionLockKeys({
+    req: {
+      token: 'test-token',
+      session: 'fresh-replay-android',
+      command: 'replay',
+      positionals: [replayPath],
+      flags: {},
+      meta: { cwd: root },
+    },
+    sessionName: 'fresh-replay-android',
+    sessionStore,
+  });
+
+  expect(keys).toEqual(['session:fresh-replay-android', 'device:ANDROID-EMULATOR']);
+  expect(mockResolveTargetDevice).toHaveBeenCalledWith({ platform: 'android' }, undefined);
+});
+
 test('open --debug writes bounded open timing diagnostics to requestLogPath', async () => {
   const sessionStore = makeSessionStore('agent-device-router-open-');
   const device = makeIosDevice('SIM-DEBUG');

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

@@ -11,7 +11,10 @@ import path from 'node:path';
 import { runReplayScriptFile } from '../session-replay-runtime.ts';
 import { SessionStore } from '../../session-store.ts';
 import { dispatchCommand, resolveTargetDevice } from '../../../core/dispatch.ts';
-import { makeIosSession } from '../../../__tests__/test-utils/session-factories.ts';
+import {
+  makeAndroidSession,
+  makeIosSession,
+} from '../../../__tests__/test-utils/session-factories.ts';
 import {
   baseReplayRequest as baseReq,
   writeReplayFile,
@@ -410,7 +413,7 @@ test('fresh typed Maestro replay resolves its configured app before runtime defa
   const response = await runReplayScriptFile({
     req: baseReq({
       positionals: [flowPath],
-      flags: { replayBackend: 'maestro' },
+      flags: { replayBackend: 'maestro', platform: 'ios' },
       runtime: { metroPort: 8081 },
     }),
     sessionName: 'default',
@@ -421,7 +424,7 @@ test('fresh typed Maestro replay resolves its configured app before runtime defa
 
   expect(response.ok).toBe(true);
   expect(mockResolveTargetDevice).toHaveBeenCalledWith(
-    { replayBackend: 'maestro' },
+    { replayBackend: 'maestro', platform: 'ios' },
     { appleSimulatorAppTarget: 'com.example.demo' },
   );
   expect(invoke).toHaveBeenCalledWith(
@@ -432,6 +435,65 @@ test('fresh typed Maestro replay resolves its configured app before runtime defa
   );
 });
 
+test('native replay applies an authored Android platform to its static app open', async () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agent-device-native-android-selection-'));
+  const sessionStore = new SessionStore(path.join(root, 'sessions'));
+  const replayPath = path.join(root, 'flow.ad');
+  fs.writeFileSync(
+    replayPath,
+    'runtime set --platform android --metro-port 8081\nopen com.example.demo\n',
+  );
+  const invoke = vi.fn(async () => ({ ok: true as const, data: {} }));
+
+  const response = await runReplayScriptFile({
+    req: baseReq({ positionals: [replayPath] }),
+    sessionName: 'default',
+    logPath: path.join(root, 'daemon.log'),
+    sessionStore,
+    invoke,
+  });
+
+  expect(response.ok).toBe(true);
+  expect(invoke).toHaveBeenCalledWith(
+    expect.objectContaining({
+      command: 'open',
+      positionals: ['com.example.demo'],
+      flags: expect.objectContaining({ platform: 'android' }),
+    }),
+  );
+});
+
+test('platform-less typed Maestro replay preserves a resolved Android device', async () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agent-device-maestro-android-selection-'));
+  const sessionStore = new SessionStore(path.join(root, 'sessions'));
+  const flowPath = path.join(root, 'flow.yaml');
+  fs.writeFileSync(flowPath, 'appId: com.example.demo\n---\n- launchApp\n');
+  const androidDevice = { ...makeAndroidSession('android').device, id: 'ANDROID-EMULATOR' };
+  mockResolveTargetDevice.mockResolvedValue(androidDevice);
+  const invoke = vi.fn(async () => ({ ok: true as const, data: {} }));
+
+  const response = await runReplayScriptFile({
+    req: baseReq({
+      positionals: [flowPath],
+      flags: { replayBackend: 'maestro' },
+      runtime: { metroPort: 8081 },
+    }),
+    sessionName: 'default',
+    logPath: path.join(root, 'daemon.log'),
+    sessionStore,
+    invoke,
+  });
+
+  expect(response.ok).toBe(true);
+  expect(mockResolveTargetDevice).toHaveBeenCalledWith({ replayBackend: 'maestro' }, {});
+  expect(invoke).toHaveBeenCalledWith(
+    expect.objectContaining({
+      command: 'open',
+      flags: expect.objectContaining({ platform: 'android', serial: 'ANDROID-EMULATOR' }),
+    }),
+  );
+});
+
 test('typed Maestro resume digest binds effective stored runtime hints', async () => {
   const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agent-device-maestro-session-runtime-'));
   const sessionStore = new SessionStore(path.join(root, 'sessions'));

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

@@ -216,7 +216,7 @@ async function resolveMaestroReplayBinding(params: {
       ? undefined
       : await resolveTargetDevice(
           req.flags ?? {},
-          buildMaestroReplayTargetDeviceResolutionOptions(program),
+          buildMaestroReplayTargetDeviceResolutionOptions(program, requestedPlatform),
         ));
   const platform = resolveMaestroPlatform(req, device);
   const runtimeHints = resolveEffectiveOpenRuntimeHints({
@@ -249,7 +249,7 @@ async function completeMaestroRuntimeBinding(
   if (params.device || !requiresDeviceRuntimeDefaults(params.runtimeHints)) return params;
   const device = await resolveTargetDevice(
     params.req.flags ?? {},
-    buildMaestroReplayTargetDeviceResolutionOptions(params.program),
+    buildMaestroReplayTargetDeviceResolutionOptions(params.program, params.platform),
   );
   return {
     device,

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

@@ -16,6 +16,7 @@ import {
 } from '../../request/progress.ts';
 import { SessionStore } from '../session-store.ts';
 import { expandSessionPath } from '../session-paths.ts';
+import { buildReplayScriptPlatformFlags } from '../replay-device-selection.ts';
 import { applySaveScriptRetarget } from '../session-action-recorder.ts';
 import { computeReplayPlanDigest } from '../../replay/plan-digest.ts';
 import { errorResponse, noActiveSessionError } from './response.ts';
@@ -491,7 +492,10 @@ function prepareReplayPlan(params: {
   if (!parsedResult.ok) return parsedResult;
   const parsed = parsedResult.value;
   const { metadata, actions, actionLines, actionSourcePaths } = parsed;
-  const replayReq = applyReplayMetadata(req, metadata);
+  const replayReq = applyReplayMetadata(
+    { ...req, flags: buildReplayScriptPlatformFlags(req.flags, actions) },
+    metadata,
+  );
   const planDigest = computeReplayPlanDigest({
     actions,
     actionLines,

src/daemon/replay-device-selection.ts

@@ -5,26 +5,47 @@ import type { ResolveTargetDeviceOptions } from '../core/dispatch-resolve.ts';
 import type { MaestroProgram } from '../compat/maestro/program-ir.ts';
 import { appleSimulatorAppTargetForOpenTarget } from './open-device-selection.ts';
 import { SessionStore } from './session-store.ts';
+import type { CommandFlags } from '../core/dispatch.ts';
 import type { DaemonRequest, SessionAction } from './types.ts';
 
+export type ReplayTargetDeviceResolution = {
+  flags: CommandFlags;
+  options: ResolveTargetDeviceOptions | undefined;
+};
+
 /**
  * Finds the first static app target a fresh replay will open.  Request binding
  * uses this before any replay action can cache an unqualified device choice.
  */
-export function buildReplayTargetDeviceResolutionOptions(
+export function buildReplayTargetDeviceResolution(
   req: DaemonRequest,
-): ResolveTargetDeviceOptions | undefined {
+): ReplayTargetDeviceResolution | undefined {
   if (req.command !== 'replay' || req.flags?.replayFrom !== undefined) return undefined;
   const filePath = req.positionals?.[0];
   if (!filePath) return undefined;
 
   try {
     const resolved = SessionStore.expandHome(filePath, req.meta?.cwd);
     const source = fs.readFileSync(resolved, 'utf8');
-    const appTarget = isMaestroReplay(req, resolved)
-      ? readMaestroReplayAppTarget(parseMaestroProgram(source, { sourcePath: resolved }))
-      : readScriptReplayAppTarget(parseReplayInput(source, req.flags).actions);
-    return appTargetResolutionOptions(appTarget);
+    if (isMaestroReplay(req, resolved)) {
+      return {
+        flags: req.flags ?? {},
+        options: buildMaestroReplayTargetDeviceResolutionOptions(
+          parseMaestroProgram(source, { sourcePath: resolved }),
+          req.flags?.platform,
+        ),
+      };
+    }
+    const parsed = parseReplayInput(source, req.flags);
+    const selection = readScriptReplaySelection(parsed.actions);
+    if (!selection.appTarget) return undefined;
+    const scriptFlags = buildReplayScriptPlatformFlags(req.flags, parsed.actions);
+    const platform = scriptFlags.platform ?? parsed.metadata.platform;
+    return {
+      flags:
+        platform && scriptFlags.platform === undefined ? { ...scriptFlags, platform } : scriptFlags,
+      options: platform === 'ios' ? appTargetResolutionOptions(selection.appTarget) : undefined,
+    };
   } catch {
     // Parsing and validation stay in the replay handler. Lock binding is only
     // advisory, so an unreadable/invalid plan must not mask its real error.
@@ -34,7 +55,9 @@ export function buildReplayTargetDeviceResolutionOptions(
 
 export function buildMaestroReplayTargetDeviceResolutionOptions(
   program: MaestroProgram,
+  platform: CommandFlags['platform'] | undefined,
 ): ResolveTargetDeviceOptions {
+  if (platform !== 'ios') return {};
   const appTarget = readMaestroReplayAppTarget(program);
   return appTargetResolutionOptions(appTarget) ?? {};
 }
@@ -46,9 +69,34 @@ function isMaestroReplay(req: DaemonRequest, filePath: string): boolean {
   );
 }
 
-function readScriptReplayAppTarget(actions: SessionAction[]): string | undefined {
-  const target = actions.find((action) => action.command === 'open')?.positionals?.[0];
-  return isStaticAppTarget(target) ? target : undefined;
+function readScriptReplaySelection(actions: SessionAction[]): {
+  appTarget: string | undefined;
+  platform: CommandFlags['platform'] | undefined;
+} {
+  let platform: CommandFlags['platform'] | undefined;
+  for (const action of actions) {
+    if (action.command === 'runtime' && action.flags.platform) {
+      platform = action.flags.platform;
+      continue;
+    }
+    if (action.command !== 'open') continue;
+    platform = action.runtime?.platform ?? platform;
+    const target = action.positionals?.[0];
+    if (isStaticAppTarget(target)) return { appTarget: target, platform };
+  }
+  return { appTarget: undefined, platform };
+}
+
+/** Applies a platform configured before the first static app open to replay dispatch. */
+export function buildReplayScriptPlatformFlags(
+  flags: CommandFlags | undefined,
+  actions: SessionAction[],
+): CommandFlags {
+  const selection = readScriptReplaySelection(actions);
+  if (flags?.platform !== undefined || !selection.appTarget || !selection.platform) {
+    return flags ?? {};
+  }
+  return { ...flags, platform: selection.platform };
 }
 
 function readMaestroReplayAppTarget(program: MaestroProgram): string | undefined {