eas-cli 2.5.1 → 2.6.0

package/build/metadata/{config.js → config/resolve.js}

@@ -1,14 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createAppleWriter = exports.createAppleReader = exports.validateConfig = exports.loadConfigAsync = exports.getStaticConfigFilePath = void 0;
+exports.createAppleWriter = exports.createAppleReader = exports.loadConfigAsync = exports.getStaticConfigFilePath = void 0;
 const tslib_1 = require("tslib");
-const ajv_1 = tslib_1.__importDefault(require("ajv"));
 const assert_1 = tslib_1.__importDefault(require("assert"));
 const fs_extra_1 = tslib_1.__importDefault(require("fs-extra"));
 const path_1 = tslib_1.__importDefault(require("path"));
-const reader_1 = require("./apple/config/reader");
-const writer_1 = require("./apple/config/writer");
-const errors_1 = require("./errors");
+const reader_1 = require("../apple/config/reader");
+const writer_1 = require("../apple/config/writer");
+const errors_1 = require("../errors");
+const validate_1 = require("./validate");
 /**
  * Resolve the dynamic config from the user.
  * It supports methods, async methods, or objects (json).
@@ -19,12 +19,23 @@ async function resolveDynamicConfigAsync(configFile) {
         ? await userConfigOrFunction()
         : userConfigOrFunction;
 }
+/**
+ * Resolve the prefered store config file name from the submit profile.
+ * This is relative to the project directory, and uses `store.config.json` by default.
+ */
+function resolveConfigFilePath(profile) {
+    var _a;
+    if ('metadataPath' in profile) {
+        return (_a = profile.metadataPath) !== null && _a !== void 0 ? _a : 'store.config.json';
+    }
+    return 'store.config.json';
+}
 /**
  * Get the static configuration file path, based on the metadata context.
  * This uses any custom name provided, but swaps out the extension for `.json`.
  */
-function getStaticConfigFilePath({ projectDir, metadataPath, }) {
-    const configFile = path_1.default.join(projectDir, metadataPath);
+function getStaticConfigFilePath({ projectDir, profile, }) {
+    const configFile = path_1.default.join(projectDir, resolveConfigFilePath(profile));
     const configExtension = path_1.default.extname(configFile);
     return path_1.default.join(projectDir, `${path_1.default.basename(configFile, configExtension)}.json`);
 }
@@ -35,37 +46,25 @@ exports.getStaticConfigFilePath = getStaticConfigFilePath;
  * It throws MetadataValidationErrors when the file doesn't exist, or contains errors.
  * The user is prompted to try anyway when errors are found.
  */
-async function loadConfigAsync({ projectDir, metadataPath, skipValidation = false, }) {
-    const configFile = path_1.default.join(projectDir, metadataPath);
+async function loadConfigAsync({ projectDir, profile, skipValidation = false, }) {
+    const configFile = path_1.default.join(projectDir, resolveConfigFilePath(profile));
     if (!(await fs_extra_1.default.pathExists(configFile))) {
         throw new errors_1.MetadataValidationError(`Metadata store config file not found: "${configFile}"`);
     }
     const configData = await resolveDynamicConfigAsync(configFile);
     if (!skipValidation) {
-        const { valid, errors: validationErrors } = validateConfig(configData);
-        if (!valid) {
-            throw new errors_1.MetadataValidationError(`Metadata store config errors found`, validationErrors);
+        const issues = (0, validate_1.validateConfig)(configData);
+        if (issues.length > 0) {
+            throw new errors_1.MetadataValidationError(`Metadata store config errors found`, issues);
         }
     }
     return configData;
 }
 exports.loadConfigAsync = loadConfigAsync;
-/**
- * Run the JSON Schema validation to normalize defaults and flag early config errors.
- * This includes validating the known store limitations for every configurable property.
- */
-function validateConfig(config) {
-    const validator = new ajv_1.default({ allErrors: true, useDefaults: true })
-        .addMetaSchema(require('ajv/lib/refs/json-schema-draft-06.json'))
-        .compile(require('../../schema/metadata-0.json'));
-    const valid = validator(config);
-    return { valid, errors: validator.errors || [] };
-}
-exports.validateConfig = validateConfig;
 /** Create a versioned deserializer to fetch App Store data from the store configuration. */
 function createAppleReader(config) {
     (0, assert_1.default)(config.configVersion === 0, 'Unsupported store configuration version');
-    (0, assert_1.default)(config.apple, 'No apple configuration found');
+    (0, assert_1.default)(config.apple !== undefined, 'No apple configuration found');
     return new reader_1.AppleConfigReader(config.apple);
 }
 exports.createAppleReader = createAppleReader;

package/build/metadata/config/schema.d.ts

@@ -0,0 +1,7 @@
+import { AppleMetadata } from '../apple/types';
+export interface MetadataConfig {
+    /** The store configuration version */
+    configVersion: number;
+    /** All App Store related configuration */
+    apple?: AppleMetadata;
+}

package/build/metadata/config/schema.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/metadata/config/validate.d.ts

@@ -0,0 +1,3 @@
+import { Issue } from './issue';
+/** Validate the user-provided validation for issues */
+export declare function validateConfig(config: unknown): Issue[];

package/build/metadata/config/validate.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateConfig = void 0;
+const rules_1 = require("../apple/rules");
+const ajv_1 = require("../utils/ajv");
+const issue_1 = require("./issue");
+const metadataSchema = require('../../../schema/metadata-0.json');
+/** Validate the user-provided validation for issues */
+function validateConfig(config) {
+    var _a;
+    const validator = (0, ajv_1.createValidator)().compile(metadataSchema);
+    validator(config);
+    const issues = (0, ajv_1.getReadableErrors)((_a = validator.errors) !== null && _a !== void 0 ? _a : []).map(error => {
+        var _a, _b;
+        const path = error.path === '$' ? [] : error.path.substring(2).split('.');
+        const id = (_b = (_a = error.original) === null || _a === void 0 ? void 0 : _a.keyword) !== null && _b !== void 0 ? _b : 'unknown';
+        return {
+            id: `json-schema.${id}`,
+            path,
+            severity: issue_1.IssueSeverity.error,
+            message: error.message,
+        };
+    });
+    try {
+        issues.push(...validateRules(rules_1.appleRules, config));
+    }
+    catch {
+        // When the rules are failing, the json schema validation errors explain the issue
+        // TODO(cedric): optionally add debugging logging for these types of errors
+    }
+    return issues;
+}
+exports.validateConfig = validateConfig;
+/** Validate the set of rules against the parsed metadata config */
+function validateRules(rules, config) {
+    const issues = [];
+    for (const rule of rules) {
+        const result = rule.validate(config);
+        if (Array.isArray(result)) {
+            issues.push(...result);
+        }
+        else if (result) {
+            issues.push(result);
+        }
+    }
+    return issues;
+}

package/build/metadata/download.d.ts

@@ -1,6 +1,15 @@
-import { MetadataContext } from './context';
+import { ExpoConfig } from '@expo/config-types';
+import { SubmitProfile } from '@expo/eas-json';
+import { Analytics } from '../analytics/AnalyticsManager';
+import { CredentialsContext } from '../credentials/context';
 /**
  * Generate a local store configuration from the stores.
  * Note, only App Store is supported at this time.
  */
-export declare function downloadMetadataAsync(metadataCtx: MetadataContext): Promise<string>;
+export declare function downloadMetadataAsync({ projectDir, profile, exp, analytics, credentialsCtx, }: {
+    projectDir: string;
+    profile: SubmitProfile;
+    exp: ExpoConfig;
+    analytics: Analytics;
+    credentialsCtx: CredentialsContext;
+}): Promise<string>;

package/build/metadata/download.js

@@ -8,19 +8,19 @@ const AnalyticsManager_1 = require("../analytics/AnalyticsManager");
 const log_1 = tslib_1.__importDefault(require("../log"));
 const prompts_1 = require("../prompts");
 const tasks_1 = require("./apple/tasks");
-const config_1 = require("./config");
-const context_1 = require("./context");
+const auth_1 = require("./auth");
+const resolve_1 = require("./config/resolve");
 const errors_1 = require("./errors");
 const telemetry_1 = require("./utils/telemetry");
 /**
  * Generate a local store configuration from the stores.
  * Note, only App Store is supported at this time.
  */
-async function downloadMetadataAsync(metadataCtx) {
-    const filePath = (0, config_1.getStaticConfigFilePath)(metadataCtx);
+async function downloadMetadataAsync({ projectDir, profile, exp, analytics, credentialsCtx, }) {
+    const filePath = (0, resolve_1.getStaticConfigFilePath)({ projectDir, profile });
     const fileExists = await fs_extra_1.default.pathExists(filePath);
     if (fileExists) {
-        const filePathRelative = path_1.default.relative(metadataCtx.projectDir, filePath);
+        const filePathRelative = path_1.default.relative(projectDir, filePath);
         const overwrite = await (0, prompts_1.confirmAsync)({
             message: `Do you want to overwrite the existing "${filePathRelative}"?`,
         });
@@ -28,13 +28,18 @@ async function downloadMetadataAsync(metadataCtx) {
             throw new errors_1.MetadataValidationError(`Store config already exists at "${filePath}"`);
         }
     }
-    const { app, auth } = await (0, context_1.ensureMetadataAppStoreAuthenticatedAsync)(metadataCtx);
-    const { unsubscribeTelemetry, executionId } = (0, telemetry_1.subscribeTelemetry)(metadataCtx.analytics, AnalyticsManager_1.MetadataEvent.APPLE_METADATA_DOWNLOAD, { app, auth });
+    const { app, auth } = await (0, auth_1.getAppStoreAuthAsync)({
+        exp,
+        credentialsCtx,
+        projectDir,
+        profile,
+    });
+    const { unsubscribeTelemetry, executionId } = (0, telemetry_1.subscribeTelemetry)(analytics, AnalyticsManager_1.MetadataEvent.APPLE_METADATA_DOWNLOAD, { app, auth });
     log_1.default.addNewLineIfNone();
     log_1.default.log('Downloading App Store config...');
     const errors = [];
-    const config = (0, config_1.createAppleWriter)();
-    const tasks = (0, tasks_1.createAppleTasks)(metadataCtx);
+    const config = (0, resolve_1.createAppleWriter)();
+    const tasks = (0, tasks_1.createAppleTasks)();
     const taskCtx = { app };
     for (const task of tasks) {
         try {

package/build/metadata/errors.d.ts

@@ -1,12 +1,12 @@
-import type { ErrorObject } from 'ajv';
+import { Issue } from './config/issue';
 /**
  * Before syncing data to the ASC API, we need to validate the metadata config.
  * This error represents unrecoverable issues before syncing that data,
  * and should contain useful information for the user to solve before trying again.
  */
 export declare class MetadataValidationError extends Error {
-    readonly errors: ErrorObject[];
-    constructor(message?: string, errors?: ErrorObject[]);
+    readonly errors: Issue[];
+    constructor(message?: string, errors?: Issue[]);
 }
 /**
  * If a single entity failed to update, we don't block the other entities from uploading.

package/build/metadata/errors.js

@@ -54,7 +54,9 @@ function logMetadataValidationError(error) {
     log_1.default.error(chalk_1.default.bold(error.message));
     if (((_a = error.errors) === null || _a === void 0 ? void 0 : _a.length) > 0) {
         // TODO(cedric): group errors by property to make multiple errors for same property more readable
-        log_1.default.log(error.errors.map(err => `  - ${chalk_1.default.bold(err.dataPath)} ${err.message}`).join('\n'));
+        for (const err of error.errors) {
+            log_1.default.log(`  - ${chalk_1.default.bold(`$.${err.path.join('.')}`)} ${err.message}`);
+        }
     }
 }
 exports.logMetadataValidationError = logMetadataValidationError;

package/build/metadata/upload.d.ts

@@ -1,8 +1,17 @@
-import { MetadataContext } from './context';
+import { ExpoConfig } from '@expo/config-types';
+import { SubmitProfile } from '@expo/eas-json';
+import { Analytics } from '../analytics/AnalyticsManager';
+import { CredentialsContext } from '../credentials/context';
 /**
  * Sync a local store configuration with the stores.
  * Note, only App Store is supported at this time.
  */
-export declare function uploadMetadataAsync(metadataCtx: MetadataContext): Promise<{
+export declare function uploadMetadataAsync({ projectDir, profile, exp, analytics, credentialsCtx, }: {
+    projectDir: string;
+    profile: SubmitProfile;
+    exp: ExpoConfig;
+    analytics: Analytics;
+    credentialsCtx: CredentialsContext;
+}): Promise<{
     appleLink: string;
 }>;

package/build/metadata/upload.js

@@ -6,24 +6,29 @@ const AnalyticsManager_1 = require("../analytics/AnalyticsManager");
 const log_1 = tslib_1.__importDefault(require("../log"));
 const prompts_1 = require("../prompts");
 const tasks_1 = require("./apple/tasks");
-const config_1 = require("./config");
-const context_1 = require("./context");
+const auth_1 = require("./auth");
+const resolve_1 = require("./config/resolve");
 const errors_1 = require("./errors");
 const telemetry_1 = require("./utils/telemetry");
 /**
  * Sync a local store configuration with the stores.
  * Note, only App Store is supported at this time.
  */
-async function uploadMetadataAsync(metadataCtx) {
+async function uploadMetadataAsync({ projectDir, profile, exp, analytics, credentialsCtx, }) {
     var _a;
-    const storeConfig = await loadConfigWithValidationPromptAsync(metadataCtx);
-    const { app, auth } = await (0, context_1.ensureMetadataAppStoreAuthenticatedAsync)(metadataCtx);
-    const { unsubscribeTelemetry, executionId } = (0, telemetry_1.subscribeTelemetry)(metadataCtx.analytics, AnalyticsManager_1.MetadataEvent.APPLE_METADATA_UPLOAD, { app, auth });
+    const storeConfig = await loadConfigWithValidationPromptAsync(projectDir, profile);
+    const { app, auth } = await (0, auth_1.getAppStoreAuthAsync)({
+        exp,
+        credentialsCtx,
+        projectDir,
+        profile,
+    });
+    const { unsubscribeTelemetry, executionId } = (0, telemetry_1.subscribeTelemetry)(analytics, AnalyticsManager_1.MetadataEvent.APPLE_METADATA_UPLOAD, { app, auth });
     log_1.default.addNewLineIfNone();
     log_1.default.log('Uploading App Store configuration...');
     const errors = [];
-    const config = (0, config_1.createAppleReader)(storeConfig);
-    const tasks = (0, tasks_1.createAppleTasks)(metadataCtx, {
+    const config = (0, resolve_1.createAppleReader)(storeConfig);
+    const tasks = (0, tasks_1.createAppleTasks)({
         // We need to resolve a different version as soon as possible.
         // This version is the parent model of all changes we are going to push.
         version: (_a = config.getVersion()) === null || _a === void 0 ? void 0 : _a.versionString,
@@ -52,9 +57,9 @@ async function uploadMetadataAsync(metadataCtx) {
     return { appleLink: `https://appstoreconnect.apple.com/apps/${app.id}/appstore` };
 }
 exports.uploadMetadataAsync = uploadMetadataAsync;
-async function loadConfigWithValidationPromptAsync(metadataCtx) {
+async function loadConfigWithValidationPromptAsync(projectDir, profile) {
     try {
-        return await (0, config_1.loadConfigAsync)(metadataCtx);
+        return await (0, resolve_1.loadConfigAsync)({ projectDir, profile });
     }
     catch (error) {
         if (error instanceof errors_1.MetadataValidationError) {
@@ -62,7 +67,7 @@ async function loadConfigWithValidationPromptAsync(metadataCtx) {
             log_1.default.newLine();
             log_1.default.warn('Without further updates, the current store configuration can fail to be synchronized with the App Store or pass App Store review.');
             if (await (0, prompts_1.confirmAsync)({ message: 'Do you still want to push the store configuration?' })) {
-                return await (0, config_1.loadConfigAsync)({ ...metadataCtx, skipValidation: true });
+                return await (0, resolve_1.loadConfigAsync)({ projectDir, profile, skipValidation: true });
             }
         }
         throw error;

package/build/metadata/utils/ajv.d.ts

@@ -0,0 +1,10 @@
+import { HumanError } from '@segment/ajv-human-errors';
+import Ajv, { ErrorObject } from 'ajv';
+/**
+ * Create a new AJV validator using the JSON Schema 06 draft.
+ * It also adds the additional formats from the `ajv-formats` package.
+ *
+ * @see https://github.com/ajv-validator/ajv-formats
+ */
+export declare function createValidator(): Ajv;
+export declare function getReadableErrors(errors?: ErrorObject[]): HumanError[];

package/build/metadata/utils/ajv.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getReadableErrors = exports.createValidator = void 0;
+const tslib_1 = require("tslib");
+const ajv_human_errors_1 = require("@segment/ajv-human-errors");
+const ajv_1 = tslib_1.__importDefault(require("ajv"));
+const ajv_formats_1 = tslib_1.__importDefault(require("ajv-formats"));
+const jsonSchema = require('ajv/lib/refs/json-schema-draft-06.json');
+/**
+ * Create a new AJV validator using the JSON Schema 06 draft.
+ * It also adds the additional formats from the `ajv-formats` package.
+ *
+ * @see https://github.com/ajv-validator/ajv-formats
+ */
+function createValidator() {
+    const validator = new ajv_1.default({
+        strict: false,
+        verbose: true,
+        allErrors: true, // Required for `ajv-human-errors`
+    });
+    return (0, ajv_formats_1.default)(validator).addMetaSchema(jsonSchema);
+}
+exports.createValidator = createValidator;
+function getReadableErrors(errors = []) {
+    if (errors.length === 0) {
+        return [];
+    }
+    return new ajv_human_errors_1.AggregateAjvError(errors).toJSON();
+}
+exports.getReadableErrors = getReadableErrors;

package/build/metadata/utils/telemetry.js

@@ -24,18 +24,18 @@ function subscribeTelemetry(analytics, event, options) {
         });
         return response;
     }, (error) => {
-        var _a, _b, _c;
+        var _a, _b, _c, _d, _e;
         analytics.logEvent(event, {
             executionId,
             type: 'response',
             phase: 'rejected',
             method: error.request.method.toUpperCase(),
-            url: scrubber(error.config.url),
+            url: scrubber((_a = error.config) === null || _a === void 0 ? void 0 : _a.url),
             error: scrubber(error.message),
-            status: String((_a = error.response) === null || _a === void 0 ? void 0 : _a.status),
-            statusText: scrubber((_b = error.response) === null || _b === void 0 ? void 0 : _b.statusText),
-            input: scrubber(error.config.data),
-            output: scrubber((_c = error.response) === null || _c === void 0 ? void 0 : _c.data),
+            status: String((_b = error.response) === null || _b === void 0 ? void 0 : _b.status),
+            statusText: scrubber((_c = error.response) === null || _c === void 0 ? void 0 : _c.statusText),
+            input: scrubber((_d = error.config) === null || _d === void 0 ? void 0 : _d.data),
+            output: scrubber((_e = error.response) === null || _e === void 0 ? void 0 : _e.data),
         });
         throw error;
     });

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,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runAppOnAndroidEmulatorAsync = void 0;
+const tslib_1 = require("tslib");
+const log_1 = tslib_1.__importDefault(require("../../log"));
+async function runAppOnAndroidEmulatorAsync(_appPath) {
+    log_1.default.error('Not implemented!');
+}
+exports.runAppOnAndroidEmulatorAsync = runAppOnAndroidEmulatorAsync;

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,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runAppOnIosSimulatorAsync = void 0;
+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);
+}
+exports.runAppOnIosSimulatorAsync = runAppOnIosSimulatorAsync;
+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,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.simctlAsync = void 0;
+const xcrun_1 = require("./xcrun");
+async function simctlAsync(args, options) {
+    return (0, xcrun_1.xcrunAsync)(['simctl', ...args], options);
+}
+exports.simctlAsync = simctlAsync;

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,161 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSimulatorAppIdAsync = exports.installAppAsync = exports.ensureSimulatorAppOpenedAsync = exports.launchAppAsync = exports.openSimulatorAppAsync = exports.ensureSimulatorBootedAsync = exports.getAvaliableIosSimulatorsListAsync = exports.getFirstBootedIosSimulatorAsync = exports.selectSimulatorAsync = void 0;
+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 log_1 = tslib_1.__importDefault(require("../../log"));
+const prompts_1 = require("../../prompts");
+const promise_1 = require("../../utils/promise");
+const simctl_1 = require("./simctl");
+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;
+}
+exports.selectSimulatorAsync = selectSimulatorAsync;
+async function getFirstBootedIosSimulatorAsync() {
+    const bootedSimulators = await getAvaliableIosSimulatorsListAsync('booted');
+    if (bootedSimulators.length > 0) {
+        return bootedSimulators[0];
+    }
+    return undefined;
+}
+exports.getFirstBootedIosSimulatorAsync = getFirstBootedIosSimulatorAsync;
+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;
+}
+exports.getAvaliableIosSimulatorsListAsync = getAvaliableIosSimulatorsListAsync;
+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]);
+}
+exports.ensureSimulatorBootedAsync = ensureSimulatorBootedAsync;
+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);
+}
+exports.openSimulatorAppAsync = openSimulatorAppAsync;
+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!');
+}
+exports.launchAppAsync = launchAppAsync;
+// 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);
+}
+exports.ensureSimulatorAppOpenedAsync = ensureSimulatorAppOpenedAsync;
+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!');
+}
+exports.installAppAsync = installAppAsync;
+async function getSimulatorAppIdAsync() {
+    try {
+        return (await osascript.execAsync('id of app "Simulator"')).trim();
+    }
+    catch {
+        return undefined;
+    }
+}
+exports.getSimulatorAppIdAsync = getSimulatorAppIdAsync;

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

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