@donotuse/eas-cli 18.5.0-rc.1

package/build/submit/utils/wait.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.waitForSubmissionsEndAsync = waitForSubmissionsEndAsync;
+const tslib_1 = require("tslib");
+const nullthrows_1 = tslib_1.__importDefault(require("nullthrows"));
+const generated_1 = require("../../graphql/generated");
+const SubmissionQuery_1 = require("../../graphql/queries/SubmissionQuery");
+const log_1 = tslib_1.__importDefault(require("../../log"));
+const ora_1 = require("../../ora");
+const promise_1 = require("../../utils/promise");
+const APP_STORE_NAMES = {
+    [generated_1.AppPlatform.Android]: 'Google Play Store',
+    [generated_1.AppPlatform.Ios]: 'Apple App Store Connect',
+};
+const CHECK_INTERVAL_MS = 5_000;
+async function waitForSubmissionsEndAsync(graphqlClient, initialSubmissions) {
+    log_1.default.log(`Waiting for submission${initialSubmissions.length > 1 ? 's' : ''} to complete. You can press Ctrl+C to exit.`);
+    const spinner = (0, ora_1.ora)(`Submitting`).start();
+    while (true) {
+        const submissions = await Promise.all(initialSubmissions.map(({ id }) => {
+            try {
+                return SubmissionQuery_1.SubmissionQuery.byIdAsync(graphqlClient, id, { useCache: false });
+            }
+            catch (err) {
+                log_1.default.debug('Failed to fetch the submission status', err);
+                return null;
+            }
+        }));
+        if (submissions.length === 1) {
+            const [submission] = submissions;
+            if (submission !== null) {
+                spinner.text = getSingleSpinnerText(submission);
+                if (submission.status === generated_1.SubmissionStatus.Finished) {
+                    spinner.succeed();
+                    return [submission];
+                }
+                else if (submission.status === generated_1.SubmissionStatus.Errored) {
+                    spinner.fail();
+                    return [submission];
+                }
+                else if (submission.status === generated_1.SubmissionStatus.Canceled) {
+                    spinner.warn();
+                    return [submission];
+                }
+            }
+            else {
+                if (!spinner.text) {
+                    spinner.text =
+                        'Could not fetch the submission status. Check your network connection. If the problem persists re-run the command with the EXPO_DEBUG=1 environment variable.';
+                }
+            }
+        }
+        else {
+            spinner.text = getMultipleSpinnerText(submissions);
+            const finished = countWithStatus(submissions, generated_1.SubmissionStatus.Finished);
+            const errored = countWithStatus(submissions, generated_1.SubmissionStatus.Errored);
+            const canceled = countWithStatus(submissions, generated_1.SubmissionStatus.Canceled);
+            const nonCompleted = submissions.length - (finished + errored + canceled);
+            if (nonCompleted === 0) {
+                if (finished === submissions.length) {
+                    spinner.succeed('All submissions have finished');
+                }
+                else {
+                    spinner.fail('Some submissions were canceled or failed');
+                }
+                return submissions.map(s => (0, nullthrows_1.default)(s));
+            }
+        }
+        await (0, promise_1.sleepAsync)(CHECK_INTERVAL_MS);
+    }
+}
+function getSingleSpinnerText(submission) {
+    const { platform, status } = submission;
+    const appStoreName = APP_STORE_NAMES[platform];
+    switch (status) {
+        case generated_1.SubmissionStatus.AwaitingBuild:
+            return `Submitting your app to ${appStoreName}: waiting for the associated build to complete`;
+        case generated_1.SubmissionStatus.InQueue:
+            return `Submitting your app to ${appStoreName}: waiting for an available submitter`;
+        case generated_1.SubmissionStatus.InProgress:
+            return `Submitting your app to ${appStoreName}: submission in progress`;
+        case generated_1.SubmissionStatus.Finished:
+            return `Submitted your app to ${appStoreName}!`;
+        case generated_1.SubmissionStatus.Errored:
+            return `Something went wrong when submitting your app to ${appStoreName}.`;
+        case generated_1.SubmissionStatus.Canceled:
+            return 'The submission has been canceled';
+    }
+}
+function getMultipleSpinnerText(submissions) {
+    const awaitingSubmissions = countWithStatus(submissions, generated_1.SubmissionStatus.AwaitingBuild);
+    const inQueue = countWithStatus(submissions, generated_1.SubmissionStatus.InQueue);
+    const inProgress = countWithStatus(submissions, generated_1.SubmissionStatus.InProgress);
+    const finished = countWithStatus(submissions, generated_1.SubmissionStatus.Finished);
+    const errored = countWithStatus(submissions, generated_1.SubmissionStatus.Errored);
+    const canceled = countWithStatus(submissions, generated_1.SubmissionStatus.Canceled);
+    const unknown = submissions.length - awaitingSubmissions - inQueue - inProgress - finished - errored - canceled;
+    const text = [
+        awaitingSubmissions && `Awaiting submissions: ${awaitingSubmissions}`,
+        inQueue && `Submissions in queue: ${inQueue}`,
+        inProgress && `Submissions in progress: ${inProgress}`,
+        canceled && `Canceled submissions: ${canceled}`,
+        errored && `Failed submissions: ${errored}`,
+        finished && `Finished submissions: ${finished}`,
+        unknown && `Submissions with unknown status: ${unknown}`,
+    ]
+        .filter(i => i)
+        .join('\t');
+    return text;
+}
+function countWithStatus(submissions, status) {
+    return submissions.filter(submission => submission?.status === status).length;
+}

package/build/update/android/UpdatesModule.d.ts

@@ -0,0 +1,12 @@
+import { ExpoConfig } from '@expo/config';
+import { Env, Workflow } from '@expo/eas-build-job';
+/**
+ * Synchronize updates configuration to native files. This needs to do essentially the same thing as `withUpdates`
+ */
+export declare function syncUpdatesConfigurationAsync({ projectDir, exp, workflow, env, }: {
+    projectDir: string;
+    exp: ExpoConfig;
+    workflow: Workflow;
+    env: Env | undefined;
+}): Promise<void>;
+export declare function readChannelSafelyAsync(projectDir: string): Promise<string | null>;

package/build/update/android/UpdatesModule.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.syncUpdatesConfigurationAsync = syncUpdatesConfigurationAsync;
+exports.readChannelSafelyAsync = readChannelSafelyAsync;
+const config_plugins_1 = require("@expo/config-plugins");
+const platform_1 = require("../../platform");
+const projectUtils_1 = require("../../project/projectUtils");
+const expoUpdatesCli_1 = require("../../utils/expoUpdatesCli");
+const utils_1 = require("../utils");
+/**
+ * Synchronize updates configuration to native files. This needs to do essentially the same thing as `withUpdates`
+ */
+async function syncUpdatesConfigurationAsync({ projectDir, exp, workflow, env, }) {
+    (0, utils_1.ensureValidVersions)(exp, platform_1.RequestedPlatform.Android);
+    if (await (0, projectUtils_1.isModernExpoUpdatesCLIWithRuntimeVersionCommandSupportedAsync)(projectDir)) {
+        await (0, expoUpdatesCli_1.expoUpdatesCommandAsync)(projectDir, ['configuration:syncnative', '--platform', 'android', '--workflow', workflow], { env });
+        return;
+    }
+    const expoUpdatesPackageVersion = await (0, projectUtils_1.getExpoUpdatesPackageVersionIfInstalledAsync)(projectDir);
+    // sync AndroidManifest.xml
+    const androidManifestPath = await config_plugins_1.AndroidConfig.Paths.getAndroidManifestAsync(projectDir);
+    const androidManifest = await getAndroidManifestAsync(projectDir);
+    const updatedAndroidManifest = await config_plugins_1.AndroidConfig.Updates.setUpdatesConfigAsync(projectDir, exp, androidManifest, expoUpdatesPackageVersion);
+    await config_plugins_1.AndroidConfig.Manifest.writeAndroidManifestAsync(androidManifestPath, updatedAndroidManifest);
+    // sync strings.xml
+    const stringsJSONPath = await config_plugins_1.AndroidConfig.Strings.getProjectStringsXMLPathAsync(projectDir);
+    const stringsResourceXML = await config_plugins_1.AndroidConfig.Resources.readResourcesXMLAsync({
+        path: stringsJSONPath,
+    });
+    // TODO(wschurman): this dependency needs to be updated for fingerprint
+    const updatedStringsResourceXML = await config_plugins_1.AndroidConfig.Updates.applyRuntimeVersionFromConfigForProjectRootAsync(projectDir, exp, stringsResourceXML);
+    await config_plugins_1.XML.writeXMLAsync({ path: stringsJSONPath, xml: updatedStringsResourceXML });
+}
+async function readChannelSafelyAsync(projectDir) {
+    try {
+        const androidManifest = await getAndroidManifestAsync(projectDir);
+        const stringifiedRequestHeaders = config_plugins_1.AndroidConfig.Manifest.getMainApplicationMetaDataValue(androidManifest, config_plugins_1.AndroidConfig.Updates.Config.UPDATES_CONFIGURATION_REQUEST_HEADERS_KEY);
+        if (!stringifiedRequestHeaders) {
+            return null;
+        }
+        return JSON.parse(stringifiedRequestHeaders)['expo-channel-name'] ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+async function getAndroidManifestAsync(projectDir) {
+    const androidManifestPath = await config_plugins_1.AndroidConfig.Paths.getAndroidManifestAsync(projectDir);
+    if (!androidManifestPath) {
+        throw new Error(`Could not find AndroidManifest.xml in project directory: "${projectDir}"`);
+    }
+    return await config_plugins_1.AndroidConfig.Manifest.readAndroidManifestAsync(androidManifestPath);
+}

package/build/update/configure.d.ts

@@ -0,0 +1,36 @@
+import { ExpoConfig } from '@expo/config';
+import { Env, Workflow } from '@expo/eas-build-job';
+import { RequestedPlatform } from '../platform';
+import { Client } from '../vcs/vcs';
+export declare const DEFAULT_MANAGED_RUNTIME_VERSION_GTE_SDK_49: {
+    readonly policy: "appVersion";
+};
+export declare const DEFAULT_MANAGED_RUNTIME_VERSION_LTE_SDK_48: {
+    readonly policy: "sdkVersion";
+};
+export declare const DEFAULT_BARE_RUNTIME_VERSION = "1.0.0";
+export declare function getDefaultRuntimeVersion(workflow: Workflow, sdkVersion: string | undefined): NonNullable<ExpoConfig['runtimeVersion']>;
+/**
+ * Make sure EAS Build profiles are configured to work with EAS Update by adding channels to build profiles.
+ */
+export declare function ensureEASUpdateIsConfiguredInEasJsonAsync(projectDir: string): Promise<void>;
+/**
+ * Make sure EAS Update is fully configured in the current project.
+ * This goes over a checklist and performs the following checks or changes:
+ *   - Ensure `updates.useClassicUpdates` (SDK 49) is not set in the app config
+ *   - Ensure the `expo-updates` package is currently installed.
+ *   - Ensure `app.json` is configured for EAS Updates
+ *     - Sets `runtimeVersion` if not set
+ *     - Sets `updates.url` if not set
+ *   - Ensure latest changes are reflected in the native config, if any
+ */
+export declare function ensureEASUpdateIsConfiguredAsync({ exp: expMaybeWithoutUpdates, projectId, projectDir, vcsClient, platform, env, forceNativeConfigSync, manifestHostOverride, }: {
+    exp: ExpoConfig;
+    projectId: string;
+    projectDir: string;
+    vcsClient: Client;
+    platform: RequestedPlatform | null;
+    env: Env | undefined;
+    forceNativeConfigSync?: boolean;
+    manifestHostOverride: string | null;
+}): Promise<void>;

package/build/update/configure.js

@@ -0,0 +1,292 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_BARE_RUNTIME_VERSION = exports.DEFAULT_MANAGED_RUNTIME_VERSION_LTE_SDK_48 = exports.DEFAULT_MANAGED_RUNTIME_VERSION_GTE_SDK_49 = void 0;
+exports.getDefaultRuntimeVersion = getDefaultRuntimeVersion;
+exports.ensureEASUpdateIsConfiguredInEasJsonAsync = ensureEASUpdateIsConfiguredInEasJsonAsync;
+exports.ensureEASUpdateIsConfiguredAsync = ensureEASUpdateIsConfiguredAsync;
+const tslib_1 = require("tslib");
+const eas_build_job_1 = require("@expo/eas-build-job");
+const eas_json_1 = require("@expo/eas-json");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const fs_extra_1 = tslib_1.__importDefault(require("fs-extra"));
+const nullthrows_1 = tslib_1.__importDefault(require("nullthrows"));
+const semver_1 = tslib_1.__importDefault(require("semver"));
+const UpdatesModule_1 = require("./android/UpdatesModule");
+const UpdatesModule_2 = require("./ios/UpdatesModule");
+const api_1 = require("../api");
+const generated_1 = require("../graphql/generated");
+const log_1 = tslib_1.__importStar(require("../log"));
+const platform_1 = require("../platform");
+const expoConfig_1 = require("../project/expoConfig");
+const projectUtils_1 = require("../project/projectUtils");
+const workflow_1 = require("../project/workflow");
+exports.DEFAULT_MANAGED_RUNTIME_VERSION_GTE_SDK_49 = { policy: 'appVersion' };
+exports.DEFAULT_MANAGED_RUNTIME_VERSION_LTE_SDK_48 = { policy: 'sdkVersion' };
+exports.DEFAULT_BARE_RUNTIME_VERSION = '1.0.0';
+function getDefaultRuntimeVersion(workflow, sdkVersion) {
+    if (workflow === eas_build_job_1.Workflow.GENERIC) {
+        return exports.DEFAULT_BARE_RUNTIME_VERSION;
+    }
+    // Expo Go supports loading appVersion SDK 49 and above
+    const hasSupportedSdk = sdkVersion && semver_1.default.satisfies(sdkVersion, '>= 49.0.0');
+    return hasSupportedSdk
+        ? exports.DEFAULT_MANAGED_RUNTIME_VERSION_GTE_SDK_49
+        : exports.DEFAULT_MANAGED_RUNTIME_VERSION_LTE_SDK_48;
+}
+function isRuntimeEqual(runtimeVersionA, runtimeVersionB) {
+    if (typeof runtimeVersionA === 'string' && typeof runtimeVersionB === 'string') {
+        return runtimeVersionA === runtimeVersionB;
+    }
+    else if (typeof runtimeVersionA === 'object' && typeof runtimeVersionB === 'object') {
+        return runtimeVersionA.policy === runtimeVersionB.policy;
+    }
+    else {
+        return false;
+    }
+}
+function replaceUndefinedObjectValues(value, replacement) {
+    for (const key in value) {
+        if (value[key] === undefined) {
+            value[key] = replacement;
+        }
+        else if (typeof value[key] === 'object') {
+            value[key] = replaceUndefinedObjectValues(value[key], replacement);
+        }
+    }
+    return value;
+}
+/**
+ * Partially merge the EAS Update config with the existing Expo config.
+ * This preserves and merges the nested update-related properties.
+ */
+function mergeExpoConfig(exp, modifyExp) {
+    return {
+        runtimeVersion: modifyExp.runtimeVersion ?? exp.runtimeVersion,
+        updates: { ...exp.updates, ...modifyExp.updates },
+        android: {
+            ...exp.android,
+            ...modifyExp.android,
+        },
+        ios: {
+            ...exp.ios,
+            ...modifyExp.ios,
+        },
+    };
+}
+/**
+ * Make sure the `app.json` is configured to use EAS Updates.
+ * This does a couple of things:
+ *   - Ensure update URL is set to the project EAS endpoint
+ *   - Ensure runtimeVersion is defined for both or individual platforms
+ *   - Output the changes made, or the changes required to make manually
+ */
+async function ensureEASUpdatesIsConfiguredInExpoConfigAsync({ exp, projectId, projectDir, platform, workflows, manifestHostOverride, }) {
+    const modifyConfig = {};
+    if (exp.updates?.url !== (0, api_1.getEASUpdateURL)(projectId, manifestHostOverride)) {
+        modifyConfig.updates = { url: (0, api_1.getEASUpdateURL)(projectId, manifestHostOverride) };
+    }
+    let androidRuntimeVersion = exp.android?.runtimeVersion ?? exp.runtimeVersion;
+    let iosRuntimeVersion = exp.ios?.runtimeVersion ?? exp.runtimeVersion;
+    if ((['all', 'android'].includes(platform) && !androidRuntimeVersion) ||
+        (['all', 'ios'].includes(platform) && !iosRuntimeVersion)) {
+        androidRuntimeVersion =
+            androidRuntimeVersion ?? getDefaultRuntimeVersion(workflows.android, exp.sdkVersion);
+        iosRuntimeVersion =
+            iosRuntimeVersion ?? getDefaultRuntimeVersion(workflows.ios, exp.sdkVersion);
+        if (platform === 'all' && isRuntimeEqual(androidRuntimeVersion, iosRuntimeVersion)) {
+            modifyConfig.runtimeVersion = androidRuntimeVersion;
+        }
+        else {
+            if (['all', 'android'].includes(platform)) {
+                modifyConfig.runtimeVersion = undefined;
+                modifyConfig.android = { runtimeVersion: androidRuntimeVersion };
+            }
+            if (['all', 'ios'].includes(platform)) {
+                modifyConfig.runtimeVersion = undefined;
+                modifyConfig.ios = { runtimeVersion: iosRuntimeVersion };
+            }
+        }
+    }
+    if (Object.keys(modifyConfig).length === 0) {
+        return { exp, projectChanged: false };
+    }
+    const mergedExp = mergeExpoConfig(exp, modifyConfig);
+    const result = await (0, expoConfig_1.createOrModifyExpoConfigAsync)(projectDir, mergedExp);
+    switch (result.type) {
+        case 'success':
+            logEasUpdatesAutoConfig({ exp, modifyConfig });
+            return {
+                projectChanged: true,
+                // TODO(cedric): fix return type of `modifyConfigAsync` to avoid `null` for type === success repsonses
+                exp: (0, nullthrows_1.default)(result.config, 'Expected config to be defined'),
+            };
+        case 'warn':
+            warnEASUpdatesManualConfig({ modifyConfig, workflows });
+            throw new Error(result.message);
+        case 'fail':
+            throw new Error(result.message);
+        default:
+            throw new Error(`Unexpected result type "${result.type}" received when modifying the project config.`);
+    }
+}
+function serializeRuntimeVersionToString(runtimeVersion) {
+    if (typeof runtimeVersion === 'object') {
+        return JSON.stringify(runtimeVersion);
+    }
+    else {
+        return runtimeVersion;
+    }
+}
+function logEasUpdatesAutoConfig({ modifyConfig, exp, }) {
+    if (modifyConfig.updates?.url) {
+        log_1.default.withTick(exp.updates?.url
+            ? `Overwrote updates.url "${exp.updates.url}" with "${modifyConfig.updates.url}"`
+            : `Configured updates.url to "${modifyConfig.updates.url}"`);
+    }
+    const androidRuntime = modifyConfig.android?.runtimeVersion ?? modifyConfig.runtimeVersion;
+    const iosRuntime = modifyConfig.ios?.runtimeVersion ?? modifyConfig.runtimeVersion;
+    if (androidRuntime && iosRuntime && androidRuntime === iosRuntime) {
+        log_1.default.withTick(`Configured runtimeVersion for ${platform_1.appPlatformDisplayNames[generated_1.AppPlatform.Android]} and ${platform_1.appPlatformDisplayNames[generated_1.AppPlatform.Ios]} with "${serializeRuntimeVersionToString(androidRuntime)}"`);
+    }
+    else {
+        if (androidRuntime) {
+            log_1.default.withTick(`Configured runtimeVersion for ${platform_1.appPlatformDisplayNames[generated_1.AppPlatform.Android]} with "${serializeRuntimeVersionToString(androidRuntime)}"`);
+        }
+        if (iosRuntime) {
+            log_1.default.withTick(`Configured runtimeVersion for ${platform_1.appPlatformDisplayNames[generated_1.AppPlatform.Ios]} with "${serializeRuntimeVersionToString(iosRuntime)}"`);
+        }
+    }
+}
+function warnEASUpdatesManualConfig({ modifyConfig, workflows, }) {
+    log_1.default.addNewLineIfNone();
+    log_1.default.warn(`It looks like you are using a dynamic configuration! ${(0, log_1.learnMore)('https://docs.expo.dev/workflow/configuration/#dynamic-configuration-with-appconfigjs)')}`);
+    log_1.default.warn(`Add the following EAS Update key-values to the project app.config.js:\n${(0, log_1.learnMore)('https://expo.fyi/eas-update-config')}\n`);
+    log_1.default.log(chalk_1.default.bold(JSON.stringify(replaceUndefinedObjectValues(modifyConfig, '<remove this key>'), null, 2)));
+    log_1.default.addNewLineIfNone();
+    if (workflows.android === eas_build_job_1.Workflow.GENERIC || workflows.ios === eas_build_job_1.Workflow.GENERIC) {
+        log_1.default.warn((0, chalk_1.default) `The native config files {bold Expo.plist & AndroidManifest.xml} must be updated to support EAS Update. ${(0, log_1.learnMore)('https://expo.fyi/eas-update-config.md#native-configuration')}`);
+    }
+    log_1.default.addNewLineIfNone();
+}
+/**
+ * Make sure that the current `app.json` configuration for EAS Updates is set natively.
+ */
+async function ensureEASUpdateIsConfiguredNativelyAsync(vcsClient, { exp, projectDir, platform, workflows, env, }) {
+    if (['all', 'android'].includes(platform) && workflows.android === eas_build_job_1.Workflow.GENERIC) {
+        await (0, UpdatesModule_1.syncUpdatesConfigurationAsync)({
+            projectDir,
+            exp,
+            workflow: workflows.android,
+            env,
+        });
+        log_1.default.withTick(`Configured ${chalk_1.default.bold('AndroidManifest.xml')} for EAS Update`);
+    }
+    if (['all', 'ios'].includes(platform) && workflows.ios === eas_build_job_1.Workflow.GENERIC) {
+        await (0, UpdatesModule_2.syncUpdatesConfigurationAsync)({
+            vcsClient,
+            projectDir,
+            exp,
+            workflow: workflows.ios,
+            env,
+        });
+        log_1.default.withTick(`Configured ${chalk_1.default.bold('Expo.plist')} for EAS Update`);
+    }
+}
+/**
+ * Make sure EAS Build profiles are configured to work with EAS Update by adding channels to build profiles.
+ */
+async function ensureEASUpdateIsConfiguredInEasJsonAsync(projectDir) {
+    const easJsonPath = eas_json_1.EasJsonAccessor.formatEasJsonPath(projectDir);
+    // Skip if eas.json doesn't exist.
+    if (!(await fs_extra_1.default.pathExists(easJsonPath))) {
+        return;
+    }
+    // Add channel to all build profiles.
+    try {
+        const easJsonAccessor = eas_json_1.EasJsonAccessor.fromProjectPath(projectDir);
+        await easJsonAccessor.readRawJsonAsync();
+        easJsonAccessor.patch(easJsonRawObject => {
+            // If there are no build profiles then we are done.
+            if (!easJsonRawObject.build) {
+                return easJsonRawObject;
+            }
+            const easBuildProfilesWithChannels = Object.keys(easJsonRawObject.build).reduce((acc, profileNameKey) => {
+                const buildProfile = easJsonRawObject.build[profileNameKey];
+                const isNotAlreadyConfigured = !buildProfile.channel;
+                if (isNotAlreadyConfigured) {
+                    return {
+                        ...acc,
+                        [profileNameKey]: {
+                            ...buildProfile,
+                            channel: profileNameKey,
+                        },
+                    };
+                }
+                return {
+                    ...acc,
+                    [profileNameKey]: {
+                        ...easJsonRawObject.build[profileNameKey],
+                    },
+                };
+            }, {});
+            return {
+                ...easJsonRawObject,
+                build: easBuildProfilesWithChannels,
+            };
+        });
+        await easJsonAccessor.writeAsync();
+        log_1.default.withTick(`Configured ${chalk_1.default.bold('eas.json')}.`);
+    }
+    catch (error) {
+        log_1.default.error(`We were not able to configure ${chalk_1.default.bold('eas.json')}. Error: ${error}.`);
+    }
+}
+/**
+ * Make sure EAS Update is fully configured in the current project.
+ * This goes over a checklist and performs the following checks or changes:
+ *   - Ensure `updates.useClassicUpdates` (SDK 49) is not set in the app config
+ *   - Ensure the `expo-updates` package is currently installed.
+ *   - Ensure `app.json` is configured for EAS Updates
+ *     - Sets `runtimeVersion` if not set
+ *     - Sets `updates.url` if not set
+ *   - Ensure latest changes are reflected in the native config, if any
+ */
+async function ensureEASUpdateIsConfiguredAsync({ exp: expMaybeWithoutUpdates, projectId, projectDir, vcsClient, platform, env, forceNativeConfigSync, manifestHostOverride, }) {
+    const hasExpoUpdates = (0, projectUtils_1.isExpoUpdatesInstalledOrAvailable)(projectDir, expMaybeWithoutUpdates.sdkVersion);
+    const hasExpoUpdatesInDevDependencies = (0, projectUtils_1.isExpoUpdatesInstalledAsDevDependency)(projectDir);
+    if (!hasExpoUpdates && !hasExpoUpdatesInDevDependencies) {
+        await (0, projectUtils_1.installExpoUpdatesAsync)(projectDir, { silent: false });
+        log_1.default.withTick('Installed expo-updates');
+    }
+    else if (hasExpoUpdatesInDevDependencies) {
+        log_1.default.warn(`The "expo-updates" package is installed as a dev dependency. This is not recommended. Move "expo-updates" to your main dependencies.`);
+    }
+    // Bail out if using a platform that doesn't require runtime versions
+    // or native setup, i.e. web.
+    if (!platform) {
+        return;
+    }
+    const workflows = await (0, workflow_1.resolveWorkflowPerPlatformAsync)(projectDir, vcsClient);
+    const { projectChanged, exp: expWithUpdates } = await ensureEASUpdatesIsConfiguredInExpoConfigAsync({
+        exp: expMaybeWithoutUpdates,
+        projectDir,
+        projectId,
+        platform,
+        workflows,
+        manifestHostOverride,
+    });
+    if (forceNativeConfigSync || projectChanged || !hasExpoUpdates) {
+        await ensureEASUpdateIsConfiguredNativelyAsync(vcsClient, {
+            exp: expWithUpdates,
+            projectDir,
+            platform,
+            workflows,
+            env,
+        });
+    }
+    if (projectChanged) {
+        log_1.default.addNewLineIfNone();
+        log_1.default.warn(`All builds of your app going forward will be eligible to receive updates published with EAS Update.`);
+        log_1.default.newLine();
+    }
+}

package/build/update/delete.d.ts

@@ -0,0 +1,5 @@
+import { ExpoGraphqlClient } from '../commandUtils/context/contextUtils/createGraphqlClient';
+import { BackgroundJobReceiptDataFragment } from '../graphql/generated';
+export declare function scheduleUpdateGroupDeletionAsync(graphqlClient: ExpoGraphqlClient, { group, }: {
+    group: string;
+}): Promise<BackgroundJobReceiptDataFragment>;

package/build/update/delete.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scheduleUpdateGroupDeletionAsync = scheduleUpdateGroupDeletionAsync;
+const tslib_1 = require("tslib");
+const graphql_tag_1 = tslib_1.__importDefault(require("graphql-tag"));
+const client_1 = require("../graphql/client");
+const BackgroundJobReceipt_1 = require("../graphql/types/BackgroundJobReceipt");
+async function scheduleUpdateGroupDeletionAsync(graphqlClient, { group, }) {
+    const result = await (0, client_1.withErrorHandlingAsync)(graphqlClient
+        .mutation((0, graphql_tag_1.default) `
+          mutation ScheduleUpdateGroupDeletion($group: ID!) {
+            update {
+              scheduleUpdateGroupDeletion(group: $group) {
+                id
+                ...BackgroundJobReceiptData
+              }
+            }
+          }
+          ${BackgroundJobReceipt_1.BackgroundJobReceiptNode}
+        `, { group })
+        .toPromise());
+    return result.update.scheduleUpdateGroupDeletion;
+}

package/build/update/getBranchFromChannelNameAndCreateAndLinkIfNotExistsAsync.d.ts

@@ -0,0 +1,5 @@
+import { ExpoGraphqlClient } from '../commandUtils/context/contextUtils/createGraphqlClient';
+export declare function getBranchFromChannelNameAndCreateAndLinkIfNotExistsAsync(graphqlClient: ExpoGraphqlClient, projectId: string, channelName: string): Promise<{
+    branchName: string;
+    branchId: string;
+}>;

package/build/update/getBranchFromChannelNameAndCreateAndLinkIfNotExistsAsync.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBranchFromChannelNameAndCreateAndLinkIfNotExistsAsync = getBranchFromChannelNameAndCreateAndLinkIfNotExistsAsync;
+const queries_1 = require("../branch/queries");
+const errors_1 = require("../channel/errors");
+const queries_2 = require("../channel/queries");
+const ChannelQuery_1 = require("../graphql/queries/ChannelQuery");
+async function getBranchFromChannelNameAndCreateAndLinkIfNotExistsAsync(graphqlClient, projectId, channelName) {
+    let branchInfo;
+    try {
+        const channel = await ChannelQuery_1.ChannelQuery.viewUpdateChannelAsync(graphqlClient, {
+            appId: projectId,
+            channelName,
+        });
+        if (channel.updateBranches.length === 1) {
+            const branch = channel.updateBranches[0];
+            branchInfo = { branchId: branch.id, branchName: branch.name };
+        }
+        else if (channel.updateBranches.length === 0) {
+            throw new Error("Channel has no branches associated with it. Run 'eas channel:edit' to map a branch");
+        }
+        else {
+            throw new Error(`Channel has multiple branches associated with it. Instead, use '--branch' instead of '--channel'`);
+        }
+    }
+    catch (error) {
+        if (!(error instanceof errors_1.ChannelNotFoundError)) {
+            throw error;
+        }
+        const { branch } = await (0, queries_1.ensureBranchExistsAsync)(graphqlClient, {
+            appId: projectId,
+            branchName: channelName,
+        });
+        const { updateChannel: { createUpdateChannelForApp: newChannel }, } = await (0, queries_2.createChannelOnAppAsync)(graphqlClient, {
+            appId: projectId,
+            channelName,
+            branchId: branch.id,
+        });
+        if (!newChannel) {
+            throw new Error(`Could not create channel with name ${channelName} on project with id ${projectId}`);
+        }
+        branchInfo = { branchId: branch.id, branchName: channelName };
+    }
+    return branchInfo;
+}

package/build/update/ios/UpdatesModule.d.ts

@@ -0,0 +1,11 @@
+import { ExpoConfig } from '@expo/config';
+import { Env, Workflow } from '@expo/eas-build-job';
+import { Client } from '../../vcs/vcs';
+export declare function syncUpdatesConfigurationAsync({ vcsClient, projectDir, exp, workflow, env, }: {
+    vcsClient: Client;
+    projectDir: string;
+    exp: ExpoConfig;
+    workflow: Workflow;
+    env: Env | undefined;
+}): Promise<void>;
+export declare function readChannelSafelyAsync(projectDir: string): Promise<string | null>;

package/build/update/ios/UpdatesModule.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.syncUpdatesConfigurationAsync = syncUpdatesConfigurationAsync;
+exports.readChannelSafelyAsync = readChannelSafelyAsync;
+const config_plugins_1 = require("@expo/config-plugins");
+const platform_1 = require("../../platform");
+const projectUtils_1 = require("../../project/projectUtils");
+const expoUpdatesCli_1 = require("../../utils/expoUpdatesCli");
+const plist_1 = require("../../utils/plist");
+const utils_1 = require("../utils");
+async function syncUpdatesConfigurationAsync({ vcsClient, projectDir, exp, workflow, env, }) {
+    (0, utils_1.ensureValidVersions)(exp, platform_1.RequestedPlatform.Ios);
+    if (await (0, projectUtils_1.isModernExpoUpdatesCLIWithRuntimeVersionCommandSupportedAsync)(projectDir)) {
+        await (0, expoUpdatesCli_1.expoUpdatesCommandAsync)(projectDir, ['configuration:syncnative', '--platform', 'ios', '--workflow', workflow], { env });
+        return;
+    }
+    const expoUpdatesPackageVersion = await (0, projectUtils_1.getExpoUpdatesPackageVersionIfInstalledAsync)(projectDir);
+    const expoPlist = await readExpoPlistAsync(projectDir);
+    // TODO(wschurman): this dependency needs to be updated for fingerprint
+    const updatedExpoPlist = await config_plugins_1.IOSConfig.Updates.setUpdatesConfigAsync(projectDir, exp, expoPlist, expoUpdatesPackageVersion);
+    await writeExpoPlistAsync(vcsClient, projectDir, updatedExpoPlist);
+}
+async function readExpoPlistAsync(projectDir) {
+    const expoPlistPath = config_plugins_1.IOSConfig.Paths.getExpoPlistPath(projectDir);
+    return ((await (0, plist_1.readPlistAsync)(expoPlistPath)) ?? {});
+}
+async function writeExpoPlistAsync(vcsClient, projectDir, expoPlist) {
+    const expoPlistPath = config_plugins_1.IOSConfig.Paths.getExpoPlistPath(projectDir);
+    await (0, plist_1.writePlistAsync)(expoPlistPath, expoPlist);
+    await vcsClient.trackFileAsync(expoPlistPath);
+}
+async function readChannelSafelyAsync(projectDir) {
+    try {
+        const expoPlist = await readExpoPlistAsync(projectDir);
+        const updatesRequestHeaders = expoPlist['EXUpdatesRequestHeaders'];
+        return updatesRequestHeaders?.['expo-channel-name'] ?? null;
+    }
+    catch {
+        return null;
+    }
+}