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 canOverrideSelector = SELECTOR_OVERRIDE_LOCK_POLICY_COMMANDS.has(req.command);
  const conflicts = canOverrideSelector
    ? []
    : existingSession
      ? listSessionSelectorConflicts(existingSession, nextFlags)
      : listFreshSessionConflicts(nextFlags, req.meta?.lockPlatform, req.command);
  const lockPlatform = req.meta?.lockPlatform;

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

  if (lockPolicy === 'strip') {
    applyStripLockPolicy(nextFlags, conflicts, lockPlatform, existingSession);
    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 shouldApplyLockPlatformDefault(
  canOverrideSelector: boolean,
  existingSession: SessionState | undefined,
  flags: CommandFlags,
  lockPlatform: LockPlatform,
): boolean {
  if (!lockPlatform || existingSession || flags.platform !== undefined) {
    return false;
  }
  if (!canOverrideSelector) {
    return true;
  }
  return !LOCKABLE_SELECTOR_KEYS.some((key) => hasSelectorValue(flags[key]));
}

function applyStripLockPolicy(
  flags: CommandFlags,
  conflicts: SessionSelectorConflict[],
  lockPlatform: LockPlatform,
  existingSession: SessionState | undefined,
): void {
  if (existingSession) {
    stripSessionConflicts(flags, conflicts);
    flags.platform = existingSession.device.platform;
    return;
  }
  stripFreshSessionConflicts(flags, lockPlatform);
}

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 (hasSelectorValue(value)) {
      conflicts.push({ key: key as SessionSelectorConflictKey, value });
    }
  }
  return conflicts;
}

function hasSelectorValue(value: unknown): value is string {
  return typeof value === 'string' && value.trim().length > 0;
}

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];
  }
}