Function inferPlatformFromSimctl

src/utils/infer-platform.ts:169–227

(
  simulatorId: string | undefined,
  simulatorName: string | undefined,
  executor: CommandExecutor,
)

}

async function inferPlatformFromSimctl(
  simulatorId: string | undefined,
  simulatorName: string | undefined,
  executor: CommandExecutor,
): Promise<SimulatorPlatform | null> {
  if (!simulatorId && !simulatorName) return null;

  const result = await executor(
    ['xcrun', 'simctl', 'list', 'devices', 'available', '--json'],
    'Infer Simulator Platform',
    true,
  );

  if (!result.success) {
    log('warn', `[Platform Inference] simctl failed: ${result.error ?? 'Unknown error'}`);
    return null;
  }

  let parsed: unknown;
  try {
    parsed = JSON.parse(result.output);
  } catch {
    log('warn', `[Platform Inference] Failed to parse simctl JSON output`);
    return null;
  }

  if (!parsed || typeof parsed !== 'object' || !('devices' in parsed)) {
    log('warn', `[Platform Inference] simctl JSON missing devices`);
    return null;
  }

  const devices = (parsed as { devices: Record<string, unknown[]> }).devices;
  for (const runtime of Object.keys(devices)) {
    const list = devices[runtime];
    if (!Array.isArray(list)) continue;

    for (const device of list) {
      if (!device || typeof device !== 'object') continue;
      const current = device as {
        udid?: unknown;
        name?: unknown;
        isAvailable?: unknown;
      };

      if (simulatorId) {
        const matchesId = typeof current.udid === 'string' && current.udid === simulatorId;
        if (!matchesId) continue;
      } else {
        const matchesName = typeof current.name === 'string' && current.name === simulatorName;
        if (!matchesName) continue;
      }
      if (typeof current.isAvailable === 'boolean' && !current.isAvailable) continue;

      return inferPlatformFromRuntime(runtime);
    }
  }

  return null;