request-lock-policy.ts

import { AppError } from '../utils/errors.ts';
import type { CommandFlags } from '../core/dispatch.ts';
import type { SessionState, DaemonRequest } from './types.ts';
import { PUBLIC_COMMANDS } from '../command-catalog.ts';
import {
  formatSessionSelectorConflict,
  listSessionSelectorConflicts,
  type SessionSelectorConflict,
  type SessionSelectorConflictKey,
} from './session-selector.ts';
import { isApplePlatform, normalizePlatformSelector } from '../utils/device.ts';

type LockPlatform = NonNullable<DaemonRequest['meta']>['lockPlatform'];

const LOCKABLE_SELECTOR_KEYS: Array<keyof CommandFlags> = [
  'target',
  'device',
  'udid',
  'serial',
  'iosSimulatorDeviceSet',
  'androidDeviceAllowlist',
];

const SELECTOR_OVERRIDE_LOCK_POLICY_COMMANDS: ReadonlySet<string> = new Set([
  PUBLIC_COMMANDS.apps,
  PUBLIC_COMMANDS.devices,
]);

export function applyRequestLockPolicy(
  req: DaemonRequest,
  existingSession?: SessionState,
): DaemonRequest {
  const lockPolicy = req.meta?.lockPolicy;
  if (!lockPolicy) {
    return req;
  }

  const nextFlags: CommandFlags = { ...(req.flags ?? {}) };
  const allowsSelectorOverride = SELECTOR_OVERRIDE_LOCK_POLICY_COMMANDS.has(req.command);
  const conflicts = allowsSelectorOverride
    ? []
    : existingSession
      ? listSessionSelectorConflicts(existingSession, nextFlags)
      : listFreshSessionConflicts(nextFlags, req.meta?.lockPlatform, req.command);
  const lockPlatform = req.meta?.lockPlatform;
  const shouldApplyLockPlatformDefault =
    !existingSession &&
    nextFlags.platform === undefined &&
    (!allowsSelectorOverride ||
      (nextFlags.serial === undefined && nextFlags.androidDeviceAllowlist === undefined));

  if (conflicts.length === 0) {
    if (lockPlatform && shouldApplyLockPlatformDefault) {
      nextFlags.platform = lockPlatform;
    }
    return {
      ...req,
      flags: nextFlags,
    };
  }

  if (lockPolicy === 'strip') {
    if (existingSession) {
      stripSessionConflicts(nextFlags, conflicts);
      nextFlags.platform = existingSession.device.platform;
    } else {
      stripFreshSessionConflicts(nextFlags, req.meta?.lockPlatform);
    }
    return {
      ...req,
      flags: nextFlags,
    };
  }

  throw new AppError(
    'INVALID_ARGS',
    `${req.command} cannot override session lock policy with ${conflicts.map(formatSessionSelectorConflict).join(', ')}. ` +
      'Unset those selectors or remove the request lock policy.',
  );
}

function listFreshSessionConflicts(
  flags: CommandFlags,
  lockPlatform: LockPlatform,
  command: DaemonRequest['command'],
): SessionSelectorConflict[] {
  const conflicts: SessionSelectorConflict[] = [];
  const normalizedLockPlatform = normalizePlatformSelector(lockPlatform);
  if (
    flags.platform !== undefined &&
    normalizedLockPlatform &&
    platformSelectorsConflict(normalizePlatformSelector(flags.platform), normalizedLockPlatform)
  ) {
    conflicts.push({ key: 'platform', value: flags.platform });
  }
  if (command === 'open') {
    return conflicts;
  }
  for (const key of LOCKABLE_SELECTOR_KEYS) {
    const value = flags[key];
    if (typeof value === 'string' && value.trim().length > 0) {
      conflicts.push({ key: key as SessionSelectorConflictKey, value });
    }
  }
  return conflicts;
}

function platformSelectorsConflict(
  requested: ReturnType<typeof normalizePlatformSelector>,
  locked: ReturnType<typeof normalizePlatformSelector>,
): boolean {
  if (!requested || !locked) return false;
  if (requested === locked) return false;
  if (requested === 'apple') return !isApplePlatform(locked);
  if (locked === 'apple') return !isApplePlatform(requested);
  return true;
}

function stripFreshSessionConflicts(flags: CommandFlags, lockPlatform: LockPlatform): void {
  for (const key of LOCKABLE_SELECTOR_KEYS) {
    delete flags[key];
  }
  if (lockPlatform) {
    flags.platform = lockPlatform;
  }
}

function stripSessionConflicts(flags: CommandFlags, conflicts: SessionSelectorConflict[]): void {
  for (const conflict of conflicts) {
    delete flags[conflict.key];
  }
}