@donotuse/eas-cli 18.5.0-rc.1

package/build/run/android/emulator.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EMULATOR_MAX_WAIT_TIMEOUT_MS = void 0;
+exports.getEmulatorExecutableAsync = getEmulatorExecutableAsync;
+exports.selectEmulatorAsync = selectEmulatorAsync;
+exports.ensureEmulatorBootedAsync = ensureEmulatorBootedAsync;
+exports.installAppAsync = installAppAsync;
+exports.startAppAsync = startAppAsync;
+const tslib_1 = require("tslib");
+const spawn_async_1 = tslib_1.__importDefault(require("@expo/spawn-async"));
+const assert_1 = tslib_1.__importDefault(require("assert"));
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const os_1 = tslib_1.__importDefault(require("os"));
+const path_1 = tslib_1.__importDefault(require("path"));
+const adb_1 = require("./adb");
+const sdk_1 = require("./sdk");
+const log_1 = tslib_1.__importDefault(require("../../log"));
+const prompts_1 = require("../../prompts");
+const filter_1 = require("../../utils/expodash/filter");
+exports.EMULATOR_MAX_WAIT_TIMEOUT_MS = 60 * 1000 * 3;
+async function getEmulatorExecutableAsync() {
+    const sdkRoot = await (0, sdk_1.getAndroidSdkRootAsync)();
+    if (sdkRoot) {
+        return path_1.default.join(sdkRoot, 'emulator', 'emulator');
+    }
+    return 'emulator';
+}
+async function emulatorAsync(...options) {
+    const emulatorExecutable = await getEmulatorExecutableAsync();
+    try {
+        return await (0, spawn_async_1.default)(emulatorExecutable, options);
+    }
+    catch (error) {
+        if (error.stderr) {
+            log_1.default.error(error.stderr);
+        }
+        throw error;
+    }
+}
+async function getAvaliableAndroidEmulatorsAsync() {
+    try {
+        const { stdout } = await emulatorAsync('-list-avds');
+        return stdout
+            .split(os_1.default.EOL)
+            .filter(filter_1.truthy)
+            .map(name => ({
+            name,
+        }));
+    }
+    catch {
+        return [];
+    }
+}
+/** Start an Android device and wait until it is booted. */
+async function bootEmulatorAsync(emulator, { timeout = exports.EMULATOR_MAX_WAIT_TIMEOUT_MS, interval = 1000, } = {}) {
+    log_1.default.newLine();
+    log_1.default.log(`Opening emulator ${chalk_1.default.bold(emulator.name)}`);
+    const emulatorExecutable = await getEmulatorExecutableAsync();
+    // Start a process to open an emulator
+    const emulatorProcess = (0, spawn_async_1.default)(emulatorExecutable, [`@${emulator.name}`], {
+        stdio: 'ignore',
+        detached: true,
+    });
+    // we don't want to wait for the emulator process to exit before we can finish `eas build:run` command
+    // https://github.com/expo/eas-cli/pull/1485#discussion_r1007935871
+    emulatorProcess.child.unref();
+    return await (0, adb_1.waitForEmulatorToBeBootedAsync)(timeout, interval);
+}
+async function selectEmulatorAsync() {
+    const runningEmulator = await (0, adb_1.getFirstRunningEmulatorAsync)();
+    if (runningEmulator) {
+        log_1.default.newLine();
+        log_1.default.log(`Using open emulator: ${chalk_1.default.bold(runningEmulator.name)}`);
+        return runningEmulator;
+    }
+    const emulators = await getAvaliableAndroidEmulatorsAsync();
+    log_1.default.newLine();
+    const { selectedEmulator } = await (0, prompts_1.promptAsync)({
+        type: 'select',
+        message: `Select an emulator to run your app on`,
+        name: 'selectedEmulator',
+        choices: emulators.map(emulator => ({
+            title: emulator.name,
+            value: emulator,
+        })),
+    });
+    return selectedEmulator;
+}
+async function ensureEmulatorBootedAsync(emulator) {
+    if (!emulator.pid || !(await (0, adb_1.isEmulatorBootedAsync)(emulator.pid))) {
+        return await bootEmulatorAsync(emulator);
+    }
+    return emulator;
+}
+async function installAppAsync(emulator, apkFilePath) {
+    log_1.default.newLine();
+    log_1.default.log('Installing your app...');
+    (0, assert_1.default)(emulator.pid);
+    await (0, adb_1.adbAsync)('-s', emulator.pid, 'install', '-r', '-d', apkFilePath);
+    log_1.default.succeed('Successfully installed your app!');
+}
+async function startAppAsync(emulator, packageName, activityName) {
+    log_1.default.newLine();
+    log_1.default.log('Starting your app...');
+    (0, assert_1.default)(emulator.pid);
+    await (0, adb_1.adbAsync)('-s', emulator.pid, 'shell', 'am', 'start', '-a', 'android.intent.action.MAIN', '-f', '0x20000000', // FLAG_ACTIVITY_SINGLE_TOP -- If set, the activity will not be launched if it is already running at the top of the history stack.
+    '-n', `${packageName}/${activityName}`);
+    log_1.default.succeed('Successfully started your app!');
+}

package/build/run/android/run.d.ts

@@ -0,0 +1 @@
+export declare function runAppOnAndroidEmulatorAsync(appPath: string): Promise<void>;

package/build/run/android/run.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runAppOnAndroidEmulatorAsync = runAppOnAndroidEmulatorAsync;
+const tslib_1 = require("tslib");
+const aapt_1 = require("./aapt");
+const emulator = tslib_1.__importStar(require("./emulator"));
+const systemRequirements_1 = require("./systemRequirements");
+async function runAppOnAndroidEmulatorAsync(appPath) {
+    await (0, systemRequirements_1.assertExecutablesExistAsync)();
+    const selectedEmulator = await emulator.selectEmulatorAsync();
+    const bootedEmulator = await emulator.ensureEmulatorBootedAsync(selectedEmulator);
+    await emulator.installAppAsync(bootedEmulator, appPath);
+    const { packageName, activityName } = await (0, aapt_1.getAptParametersAsync)(appPath);
+    await emulator.startAppAsync(bootedEmulator, packageName, activityName);
+}

package/build/run/android/sdk.d.ts

@@ -0,0 +1,2 @@
+export declare const ANDROID_DEFAULT_LOCATION: Readonly<Partial<Record<NodeJS.Platform, string>>>;
+export declare function getAndroidSdkRootAsync(): Promise<string | null>;

package/build/run/android/sdk.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ANDROID_DEFAULT_LOCATION = void 0;
+exports.getAndroidSdkRootAsync = getAndroidSdkRootAsync;
+const tslib_1 = require("tslib");
+const fs_extra_1 = require("fs-extra");
+const os_1 = tslib_1.__importDefault(require("os"));
+const path_1 = tslib_1.__importDefault(require("path"));
+exports.ANDROID_DEFAULT_LOCATION = {
+    darwin: path_1.default.join(os_1.default.homedir(), 'Library', 'Android', 'sdk'),
+    linux: path_1.default.join(os_1.default.homedir(), 'Android', 'Sdk'),
+    win32: path_1.default.join(os_1.default.homedir(), 'AppData', 'Local', 'Android', 'Sdk'),
+};
+const ANDROID_DEFAULT_LOCATION_FOR_CURRENT_PLATFORM = exports.ANDROID_DEFAULT_LOCATION[process.platform];
+async function getAndroidSdkRootAsync() {
+    if (process.env.ANDROID_HOME && (await (0, fs_extra_1.pathExists)(process.env.ANDROID_HOME))) {
+        return process.env.ANDROID_HOME;
+    }
+    else if (process.env.ANDROID_SDK_ROOT && (await (0, fs_extra_1.pathExists)(process.env.ANDROID_SDK_ROOT))) {
+        return process.env.ANDROID_SDK_ROOT;
+    }
+    else if (ANDROID_DEFAULT_LOCATION_FOR_CURRENT_PLATFORM &&
+        (await (0, fs_extra_1.pathExists)(ANDROID_DEFAULT_LOCATION_FOR_CURRENT_PLATFORM))) {
+        return ANDROID_DEFAULT_LOCATION_FOR_CURRENT_PLATFORM;
+    }
+    else {
+        return null;
+    }
+}

package/build/run/android/systemRequirements.d.ts

@@ -0,0 +1 @@
+export declare function assertExecutablesExistAsync(): Promise<void>;

package/build/run/android/systemRequirements.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertExecutablesExistAsync = assertExecutablesExistAsync;
+const tslib_1 = require("tslib");
+const spawn_async_1 = tslib_1.__importDefault(require("@expo/spawn-async"));
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const aapt_1 = require("./aapt");
+const adb_1 = require("./adb");
+const emulator_1 = require("./emulator");
+async function assertExecutableExistsAsync(executable, options) {
+    try {
+        await (0, spawn_async_1.default)(executable, options);
+    }
+    catch (err) {
+        throw new Error(`${chalk_1.default.bold(executable)} executable doesn't seem to work. Please make sure Android Studio is installed on your device and ${chalk_1.default.bold('ANDROID_HOME')} or ${chalk_1.default.bold('ANDROID_SDK_ROOT')} env variables are set.
+${err.message}`);
+    }
+}
+async function assertExecutablesExistAsync() {
+    await assertExecutableExistsAsync(await (0, adb_1.getAdbExecutableAsync)(), ['--version']);
+    await assertExecutableExistsAsync(await (0, emulator_1.getEmulatorExecutableAsync)(), ['-list-avds']);
+    await assertExecutableExistsAsync(await (0, aapt_1.getAaptExecutableAsync)(), ['version']);
+}

package/build/run/ios/run.d.ts

@@ -0,0 +1 @@
+export declare function runAppOnIosSimulatorAsync(appPath: string): Promise<void>;

package/build/run/ios/run.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runAppOnIosSimulatorAsync = runAppOnIosSimulatorAsync;
+const tslib_1 = require("tslib");
+const spawn_async_1 = tslib_1.__importDefault(require("@expo/spawn-async"));
+const path_1 = tslib_1.__importDefault(require("path"));
+const simulator = tslib_1.__importStar(require("./simulator"));
+const systemRequirements_1 = require("./systemRequirements");
+async function runAppOnIosSimulatorAsync(appPath) {
+    await (0, systemRequirements_1.validateSystemRequirementsAsync)();
+    const selectedSimulator = await simulator.selectSimulatorAsync();
+    await simulator.ensureSimulatorBootedAsync(selectedSimulator);
+    await simulator.ensureSimulatorAppOpenedAsync(selectedSimulator.udid);
+    const bundleIdentifier = await getAppBundleIdentifierAsync(appPath);
+    await simulator.installAppAsync(selectedSimulator.udid, appPath);
+    await simulator.launchAppAsync(selectedSimulator.udid, bundleIdentifier);
+}
+async function getAppBundleIdentifierAsync(appPath) {
+    const { stdout, stderr } = await (0, spawn_async_1.default)('xcrun', [
+        'plutil',
+        '-extract',
+        'CFBundleIdentifier',
+        'raw',
+        path_1.default.join(appPath, 'Info.plist'),
+    ]);
+    if (!stdout) {
+        throw new Error(`Could not read app bundle identifier from ${path_1.default.join(appPath, 'Info.plist')}: ${stderr}`);
+    }
+    return stdout.trim();
+}

package/build/run/ios/simctl.d.ts

@@ -0,0 +1,2 @@
+import { SpawnOptions, SpawnResult } from '@expo/spawn-async';
+export declare function simctlAsync(args: string[], options?: SpawnOptions): Promise<SpawnResult>;

package/build/run/ios/simctl.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.simctlAsync = simctlAsync;
+const xcrun_1 = require("./xcrun");
+async function simctlAsync(args, options) {
+    return await (0, xcrun_1.xcrunAsync)(['simctl', ...args], options);
+}

package/build/run/ios/simulator.d.ts

@@ -0,0 +1,21 @@
+interface IosSimulator {
+    runtime: string;
+    osVersion: string;
+    windowName: string;
+    osType: 'iOS';
+    state: 'Booted' | 'Shutdown';
+    isAvailable: boolean;
+    name: string;
+    udid: string;
+    lastBootedAt?: Date;
+}
+export declare function selectSimulatorAsync(): Promise<IosSimulator>;
+export declare function getFirstBootedIosSimulatorAsync(): Promise<IosSimulator | undefined>;
+export declare function getAvaliableIosSimulatorsListAsync(query?: string): Promise<IosSimulator[]>;
+export declare function ensureSimulatorBootedAsync(simulator: IosSimulator): Promise<void>;
+export declare function openSimulatorAppAsync(simulatorUdid: string): Promise<void>;
+export declare function launchAppAsync(simulatorUdid: string, bundleIdentifier: string): Promise<void>;
+export declare function ensureSimulatorAppOpenedAsync(simulatorUuid: string): Promise<void>;
+export declare function installAppAsync(deviceId: string, filePath: string): Promise<void>;
+export declare function getSimulatorAppIdAsync(): Promise<string | undefined>;
+export {};

package/build/run/ios/simulator.js

@@ -0,0 +1,160 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.selectSimulatorAsync = selectSimulatorAsync;
+exports.getFirstBootedIosSimulatorAsync = getFirstBootedIosSimulatorAsync;
+exports.getAvaliableIosSimulatorsListAsync = getAvaliableIosSimulatorsListAsync;
+exports.ensureSimulatorBootedAsync = ensureSimulatorBootedAsync;
+exports.openSimulatorAppAsync = openSimulatorAppAsync;
+exports.launchAppAsync = launchAppAsync;
+exports.ensureSimulatorAppOpenedAsync = ensureSimulatorAppOpenedAsync;
+exports.installAppAsync = installAppAsync;
+exports.getSimulatorAppIdAsync = getSimulatorAppIdAsync;
+const tslib_1 = require("tslib");
+const osascript = tslib_1.__importStar(require("@expo/osascript"));
+const spawn_async_1 = tslib_1.__importDefault(require("@expo/spawn-async"));
+const simctl_1 = require("./simctl");
+const log_1 = tslib_1.__importDefault(require("../../log"));
+const prompts_1 = require("../../prompts");
+const promise_1 = require("../../utils/promise");
+async function selectSimulatorAsync() {
+    const bootedSimulator = await getFirstBootedIosSimulatorAsync();
+    if (bootedSimulator) {
+        return bootedSimulator;
+    }
+    const simulators = await getAvaliableIosSimulatorsListAsync();
+    log_1.default.newLine();
+    const { selectedSimulator } = await (0, prompts_1.promptAsync)({
+        type: 'select',
+        message: `Select a simulator to run your app on`,
+        name: 'selectedSimulator',
+        choices: simulators.map(simulator => ({
+            title: `iOS ${simulator.osVersion} ${simulator.name}`,
+            value: simulator,
+        })),
+    });
+    return selectedSimulator;
+}
+async function getFirstBootedIosSimulatorAsync() {
+    const bootedSimulators = await getAvaliableIosSimulatorsListAsync('booted');
+    if (bootedSimulators.length > 0) {
+        return bootedSimulators[0];
+    }
+    return undefined;
+}
+async function getAvaliableIosSimulatorsListAsync(query) {
+    const { stdout } = query
+        ? await (0, simctl_1.simctlAsync)(['list', 'devices', '--json', query])
+        : await (0, simctl_1.simctlAsync)(['list', 'devices', '--json']);
+    const info = parseSimControlJsonResults(stdout);
+    const iosSimulators = [];
+    for (const runtime of Object.keys(info.devices)) {
+        // Given a string like 'com.apple.CoreSimulator.SimRuntime.tvOS-13-4'
+        const runtimeSuffix = runtime.split('com.apple.CoreSimulator.SimRuntime.').pop();
+        if (!runtimeSuffix) {
+            continue;
+        }
+        // Create an array [tvOS, 13, 4]
+        const [osType, ...osVersionComponents] = runtimeSuffix.split('-');
+        if (osType === 'iOS') {
+            // Join the end components [13, 4] -> '13.4'
+            const osVersion = osVersionComponents.join('.');
+            const sims = info.devices[runtime];
+            for (const device of sims) {
+                if (device.isAvailable) {
+                    iosSimulators.push({
+                        ...device,
+                        runtime,
+                        osVersion,
+                        windowName: `${device.name} (${osVersion})`,
+                        osType: 'iOS',
+                        state: device.state,
+                        lastBootedAt: device.lastBootedAt ? new Date(device.lastBootedAt) : undefined,
+                    });
+                }
+            }
+        }
+    }
+    return iosSimulators;
+}
+function parseSimControlJsonResults(input) {
+    try {
+        return JSON.parse(input);
+    }
+    catch (error) {
+        // Nov 15, 2020: Observed this can happen when opening the simulator and the simulator prompts the user to update the xcode command line tools.
+        // Unexpected token I in JSON at position 0
+        if (error.message.includes('Unexpected token')) {
+            log_1.default.error(`Apple's simctl returned malformed JSON:\n${input}`);
+        }
+        throw error;
+    }
+}
+async function ensureSimulatorBootedAsync(simulator) {
+    if (simulator.state === 'Booted') {
+        return;
+    }
+    await (0, simctl_1.simctlAsync)(['boot', simulator.udid]);
+}
+async function openSimulatorAppAsync(simulatorUdid) {
+    const args = ['-a', 'Simulator'];
+    if (simulatorUdid) {
+        // This has no effect if the app is already running.
+        args.push('--args', '-CurrentDeviceUDID', simulatorUdid);
+    }
+    await (0, spawn_async_1.default)('open', args);
+}
+async function launchAppAsync(simulatorUdid, bundleIdentifier) {
+    log_1.default.newLine();
+    log_1.default.log('Launching your app...');
+    await (0, simctl_1.simctlAsync)(['launch', simulatorUdid, bundleIdentifier]);
+    log_1.default.succeed('Successfully launched your app!');
+}
+// I think the app can be open while no simulators are booted.
+async function waitForSimulatorAppToStartAsync(maxWaitTimeMs, intervalMs) {
+    log_1.default.newLine();
+    log_1.default.log('Waiting for Simulator app to start...');
+    const startTime = Date.now();
+    while (Date.now() - startTime < maxWaitTimeMs) {
+        if (await isSimulatorAppRunningAsync()) {
+            return;
+        }
+        await (0, promise_1.sleepAsync)(Math.min(intervalMs, Math.max(maxWaitTimeMs - (Date.now() - startTime), 0)));
+    }
+    throw new Error('Timed out waiting for the iOS simulator to start.');
+}
+async function isSimulatorAppRunningAsync() {
+    try {
+        const result = await osascript.execAsync('tell app "System Events" to count processes whose name is "Simulator"');
+        if (result.trim() === '0') {
+            return false;
+        }
+    }
+    catch (error) {
+        if (error.message.includes('Application isn’t running')) {
+            return false;
+        }
+        throw error;
+    }
+    return true;
+}
+async function ensureSimulatorAppOpenedAsync(simulatorUuid) {
+    if (await isSimulatorAppRunningAsync()) {
+        return;
+    }
+    await openSimulatorAppAsync(simulatorUuid);
+    await waitForSimulatorAppToStartAsync(60 * 1000, 1000);
+}
+async function installAppAsync(deviceId, filePath) {
+    log_1.default.newLine();
+    log_1.default.log('Installing your app on the simulator...');
+    await (0, simctl_1.simctlAsync)(['install', deviceId, filePath]);
+    log_1.default.succeed('Successfully installed your app on the simulator!');
+}
+async function getSimulatorAppIdAsync() {
+    try {
+        return (await osascript.execAsync('id of app "Simulator"')).trim();
+    }
+    catch {
+        return undefined;
+    }
+}

package/build/run/ios/systemRequirements.d.ts

@@ -0,0 +1 @@
+export declare function validateSystemRequirementsAsync(): Promise<void>;

package/build/run/ios/systemRequirements.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateSystemRequirementsAsync = validateSystemRequirementsAsync;
+const tslib_1 = require("tslib");
+const spawn_async_1 = tslib_1.__importDefault(require("@expo/spawn-async"));
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const semver_1 = tslib_1.__importDefault(require("semver"));
+const simulator_1 = require("./simulator");
+const xcode = tslib_1.__importStar(require("./xcode"));
+const xcrun_1 = require("./xcrun");
+const log_1 = tslib_1.__importDefault(require("../../log"));
+const prompts_1 = require("../../prompts");
+function assertPlatform() {
+    if (process.platform !== 'darwin') {
+        log_1.default.error('iOS simulator apps can only be run on macOS devices.');
+        throw Error('iOS simulator apps can only be run on macOS devices.');
+    }
+}
+async function assertCorrectXcodeVersionInstalledAsync() {
+    const xcodeVersion = await xcode.getXcodeVersionAsync();
+    if (!xcodeVersion) {
+        const { goToAppStore } = await (0, prompts_1.promptAsync)({
+            type: 'select',
+            message: 'Xcode needs to be installed, would you like to continue to the App Store?',
+            name: 'goToAppStore',
+            choices: [
+                { title: 'Yes', value: true },
+                { title: 'No', value: false },
+            ],
+        });
+        if (goToAppStore) {
+            await xcode.openAppStoreAsync(xcode.APP_STORE_ID);
+        }
+        throw Error('Please try again once Xcode is installed');
+    }
+    if (semver_1.default.lt(xcodeVersion, xcode.MIN_XCODE_VERSION)) {
+        throw Error(`Xcode version ${chalk_1.default.bold(xcodeVersion)} is too old. Please upgrade to version ${chalk_1.default.bold(xcode.MIN_XCODE_VERSION)} or higher.`);
+    }
+}
+async function ensureXcrunInstalledAsync() {
+    if (!(await (0, xcrun_1.isXcrunInstalledAsync)())) {
+        const { installXcrun } = await (0, prompts_1.promptAsync)({
+            type: 'select',
+            message: 'Xcode Command Line Tools need to be installed, continue?',
+            name: 'installXcrun',
+            choices: [
+                { title: 'Yes', value: true },
+                { title: 'No', value: false },
+            ],
+        });
+        if (installXcrun) {
+            await (0, xcrun_1.installXcrunAsync)();
+            return;
+        }
+        throw Error('Please try again once Xcode Command Line Tools are installed');
+    }
+}
+async function assertSimulatorAppInstalledAsync() {
+    const simulatorAppId = await (0, simulator_1.getSimulatorAppIdAsync)();
+    if (!simulatorAppId) {
+        throw new Error(`Can't determine id of Simulator app; the Simulator is most likely not installed on this machine. Run 'sudo xcode-select -s /Applications/Xcode.app/Contents/Developer'`);
+    }
+    if (simulatorAppId !== 'com.apple.iphonesimulator' &&
+        simulatorAppId !== 'com.apple.CoreSimulator.SimulatorTrampoline') {
+        throw new Error(`Simulator is installed but is identified as '${simulatorAppId}', can't recognize what that is`);
+    }
+    try {
+        // make sure we can run simctl
+        await (0, spawn_async_1.default)('xcrun', ['simctl', 'help']);
+    }
+    catch (error) {
+        log_1.default.warn(`Unable to run simctl:\n${error.toString()}`);
+        throw new Error('xcrun is not configured correctly. Ensure `sudo xcode-select --reset` works before running this command again.');
+    }
+}
+async function validateSystemRequirementsAsync() {
+    assertPlatform();
+    await assertCorrectXcodeVersionInstalledAsync();
+    await ensureXcrunInstalledAsync();
+    await assertSimulatorAppInstalledAsync();
+}

package/build/run/ios/xcode.d.ts

@@ -0,0 +1,19 @@
+export declare const MIN_XCODE_VERSION = "9.4.0";
+export declare const APP_STORE_ID = "497799835";
+export declare function getXcodeVersionAsync(): Promise<string | undefined>;
+type XcodeBuildSettings = {
+    action: string;
+    buildSettings: {
+        BUILD_DIR: string;
+        CONFIGURATION_BUILD_DIR: string;
+        EXECUTABLE_FOLDER_PATH: string;
+        PRODUCT_BUNDLE_IDENTIFIER: string;
+        TARGET_BUILD_DIR: string;
+        UNLOCALIZED_RESOURCES_FOLDER_PATH: string;
+    };
+    target: string;
+};
+export declare function getXcodeBuildSettingsAsync(xcworkspacePath: string, scheme: string): Promise<XcodeBuildSettings[]>;
+export declare function resolveXcodeProjectAsync(projectRoot: string): Promise<string | undefined>;
+export declare function openAppStoreAsync(appId: string): Promise<void>;
+export {};

package/build/run/ios/xcode.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.APP_STORE_ID = exports.MIN_XCODE_VERSION = void 0;
+exports.getXcodeVersionAsync = getXcodeVersionAsync;
+exports.getXcodeBuildSettingsAsync = getXcodeBuildSettingsAsync;
+exports.resolveXcodeProjectAsync = resolveXcodeProjectAsync;
+exports.openAppStoreAsync = openAppStoreAsync;
+const tslib_1 = require("tslib");
+const spawn_async_1 = tslib_1.__importDefault(require("@expo/spawn-async"));
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const fast_glob_1 = tslib_1.__importDefault(require("fast-glob"));
+const semver_1 = tslib_1.__importDefault(require("semver"));
+const log_1 = tslib_1.__importDefault(require("../../log"));
+// Based on the RN docs (Aug 2020).
+exports.MIN_XCODE_VERSION = '9.4.0';
+exports.APP_STORE_ID = '497799835';
+async function getXcodeVersionAsync() {
+    try {
+        const { stdout } = await (0, spawn_async_1.default)('xcodebuild', ['-version']);
+        const version = stdout.match(/Xcode (\d+\.\d+)/)?.[1];
+        const semverFormattedVersion = `${version}.0`;
+        if (!semver_1.default.valid(semverFormattedVersion)) {
+            log_1.default.warn(`Xcode version ${chalk_1.default.bold(version)} is in unknown format. Expected format is ${chalk_1.default.bold('12.0')}.`);
+            return undefined;
+        }
+        return semverFormattedVersion;
+    }
+    catch {
+        // not installed
+        return undefined;
+    }
+}
+async function getXcodeBuildSettingsAsync(xcworkspacePath, scheme) {
+    const { stdout } = await (0, spawn_async_1.default)('xcodebuild', [
+        '-workspace',
+        xcworkspacePath,
+        '-scheme',
+        scheme,
+        '-showBuildSettings',
+        '-json',
+    ]);
+    return JSON.parse(stdout);
+}
+async function resolveXcodeProjectAsync(projectRoot) {
+    const ignoredPaths = ['**/@(Carthage|Pods|vendor|node_modules)/**'];
+    const paths = await (0, fast_glob_1.default)(`ios/*.xcworkspace`, {
+        cwd: projectRoot,
+        onlyDirectories: true,
+        ignore: ignoredPaths,
+    });
+    return paths[0];
+}
+async function openAppStoreAsync(appId) {
+    const link = getAppStoreLink(appId);
+    await (0, spawn_async_1.default)(`open`, [link]);
+}
+function getAppStoreLink(appId) {
+    if (process.platform === 'darwin') {
+        // TODO: Is there ever a case where the macappstore isn't available on mac?
+        return `macappstore://itunes.apple.com/app/id${appId}`;
+    }
+    return `https://apps.apple.com/us/app/id${appId}`;
+}

package/build/run/ios/xcrun.d.ts

@@ -0,0 +1,4 @@
+import { SpawnOptions, SpawnResult } from '@expo/spawn-async';
+export declare function xcrunAsync(args: string[], options?: SpawnOptions): Promise<SpawnResult>;
+export declare function isXcrunInstalledAsync(): Promise<boolean>;
+export declare function installXcrunAsync(): Promise<void>;

package/build/run/ios/xcrun.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.xcrunAsync = xcrunAsync;
+exports.isXcrunInstalledAsync = isXcrunInstalledAsync;
+exports.installXcrunAsync = installXcrunAsync;
+const tslib_1 = require("tslib");
+const spawn_async_1 = tslib_1.__importDefault(require("@expo/spawn-async"));
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const log_1 = tslib_1.__importDefault(require("../../log"));
+const promise_1 = require("../../utils/promise");
+async function xcrunAsync(args, options) {
+    try {
+        return await (0, spawn_async_1.default)('xcrun', args, options);
+    }
+    catch (e) {
+        throwXcrunError(e);
+    }
+}
+function throwXcrunError(e) {
+    if (isLicenseOutOfDate(e.stdout) || isLicenseOutOfDate(e.stderr)) {
+        throw new Error('Xcode license is not accepted. Please run `sudo xcodebuild -license`.');
+    }
+    else if (e.stderr?.includes('not a developer tool or in PATH')) {
+        throw new Error(`You may need to run ${chalk_1.default.bold('sudo xcode-select -s /Applications/Xcode.app')} and try again.`);
+    }
+    if (Array.isArray(e.output)) {
+        e.message += '\n' + e.output.join('\n').trim();
+    }
+    else if (e.stderr) {
+        e.message += '\n' + e.stderr;
+    }
+    throw new Error(`Some other error occurred while running xcrun command.
+  ${e.message}`);
+}
+function isLicenseOutOfDate(text) {
+    if (!text) {
+        return false;
+    }
+    const lower = text.toLowerCase();
+    return lower.includes('xcode') && lower.includes('license');
+}
+async function isXcrunInstalledAsync() {
+    try {
+        await (0, spawn_async_1.default)('xcrun', ['--version']);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function installXcrunAsync() {
+    await (0, spawn_async_1.default)('xcode-select', ['--install']);
+    await waitForXcrunInstallToFinishAsync(60 * 1000, 1000);
+}
+async function waitForXcrunInstallToFinishAsync(maxWaitTimeMs, intervalMs) {
+    log_1.default.newLine();
+    log_1.default.log('Waiting for Xcode Command Line Tools install to finish...');
+    const startTime = Date.now();
+    while (Date.now() - startTime < maxWaitTimeMs) {
+        if (await isXcrunInstalledAsync()) {
+            return;
+        }
+        await (0, promise_1.sleepAsync)(Math.min(intervalMs, Math.max(maxWaitTimeMs - (Date.now() - startTime), 0)));
+    }
+    throw new Error('Timed out waiting for Xcode Command Line Tools install to finish');
+}