@donotuse/eas-cli 18.5.0-rc.1

package/build/build/build.js

@@ -0,0 +1,530 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prepareBuildRequestForPlatformAsync = prepareBuildRequestForPlatformAsync;
+exports.handleBuildRequestError = handleBuildRequestError;
+exports.waitForBuildEndAsync = waitForBuildEndAsync;
+const tslib_1 = require("tslib");
+const eas_build_job_1 = require("@expo/eas-build-job");
+const assert_1 = tslib_1.__importDefault(require("assert"));
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const cli_progress_1 = tslib_1.__importDefault(require("cli-progress"));
+const fs_extra_1 = tslib_1.__importDefault(require("fs-extra"));
+const nullthrows_1 = tslib_1.__importDefault(require("nullthrows"));
+const errors_1 = require("./errors");
+const graphql_1 = require("./graphql");
+const local_1 = require("./local");
+const metadata_1 = require("./metadata");
+const printBuildInfo_1 = require("./utils/printBuildInfo");
+const repository_1 = require("./utils/repository");
+const AnalyticsManager_1 = require("../analytics/AnalyticsManager");
+const common_1 = require("../analytics/common");
+const api_1 = require("../api");
+const cli_1 = require("../fingerprint/cli");
+const generated_1 = require("../graphql/generated");
+const BuildMutation_1 = require("../graphql/mutations/BuildMutation");
+const BuildQuery_1 = require("../graphql/queries/BuildQuery");
+const log_1 = tslib_1.__importStar(require("../log"));
+const ora_1 = require("../ora");
+const platform_1 = require("../platform");
+const maybeUploadFingerprintAsync_1 = require("../project/maybeUploadFingerprintAsync");
+const resolveRuntimeVersionAsync_1 = require("../project/resolveRuntimeVersionAsync");
+const uploads_1 = require("../uploads");
+const files_1 = require("../utils/files");
+const json_1 = require("../utils/json");
+const progress_1 = require("../utils/progress");
+const promise_1 = require("../utils/promise");
+function resolveBuildParamsInput(ctx, metadata) {
+    return {
+        resourceClass: ctx.resourceClass,
+        sdkVersion: metadata.sdkVersion,
+        reactNativeVersion: metadata.reactNativeVersion,
+    };
+}
+async function prepareBuildRequestForPlatformAsync(builder) {
+    const { ctx } = builder;
+    const credentialsResult = await (0, common_1.withAnalyticsAsync)(ctx.analytics, async () => await builder.ensureCredentialsAsync(ctx), {
+        attemptEvent: AnalyticsManager_1.BuildEvent.GATHER_CREDENTIALS_ATTEMPT,
+        successEvent: AnalyticsManager_1.BuildEvent.GATHER_CREDENTIALS_SUCCESS,
+        failureEvent: AnalyticsManager_1.BuildEvent.GATHER_CREDENTIALS_FAIL,
+        properties: ctx.analyticsEventProperties,
+    });
+    await (0, common_1.withAnalyticsAsync)(ctx.analytics, async () => {
+        await builder.syncProjectConfigurationAsync(ctx);
+    }, {
+        attemptEvent: AnalyticsManager_1.BuildEvent.CONFIGURE_PROJECT_ATTEMPT,
+        successEvent: AnalyticsManager_1.BuildEvent.CONFIGURE_PROJECT_SUCCESS,
+        failureEvent: AnalyticsManager_1.BuildEvent.CONFIGURE_PROJECT_FAIL,
+        properties: ctx.analyticsEventProperties,
+    });
+    if (await ctx.vcsClient.isCommitRequiredAsync()) {
+        log_1.default.addNewLineIfNone();
+        const platformToRequestedPlatform = {
+            [eas_build_job_1.Platform.ANDROID]: platform_1.RequestedPlatform.Android,
+            [eas_build_job_1.Platform.IOS]: platform_1.RequestedPlatform.Ios,
+        };
+        await (0, repository_1.reviewAndCommitChangesAsync)(ctx.vcsClient, `[EAS Build] Run EAS Build for ${platform_1.requestedPlatformDisplayNames[platformToRequestedPlatform[ctx.platform]]}`, { nonInteractive: ctx.nonInteractive });
+    }
+    let projectArchive;
+    if (ctx.localBuildOptions.localBuildMode === local_1.LocalBuildMode.LOCAL_BUILD_PLUGIN) {
+        const projectPath = (await (0, repository_1.makeProjectTarballAsync)(ctx.vcsClient)).path;
+        projectArchive = {
+            type: eas_build_job_1.ArchiveSourceType.PATH,
+            path: projectPath,
+        };
+    }
+    else if (ctx.localBuildOptions.localBuildMode === local_1.LocalBuildMode.INTERNAL) {
+        projectArchive = {
+            type: eas_build_job_1.ArchiveSourceType.PATH,
+            path: process.cwd(),
+        };
+    }
+    else if (!ctx.localBuildOptions.localBuildMode) {
+        projectArchive = {
+            type: eas_build_job_1.ArchiveSourceType.GCS,
+            ...(await uploadProjectAsync(ctx)),
+        };
+    }
+    (0, assert_1.default)(projectArchive);
+    const runtimeAndFingerprintMetadata = await computeAndMaybeUploadRuntimeAndFingerprintMetadataAsync(ctx);
+    const metadata = await (0, metadata_1.collectMetadataAsync)(ctx, runtimeAndFingerprintMetadata);
+    const buildParams = resolveBuildParamsInput(ctx, metadata);
+    const job = await builder.prepareJobAsync(ctx, {
+        projectArchive,
+        credentials: credentialsResult?.credentials,
+    });
+    return async () => {
+        if (ctx.localBuildOptions.localBuildMode === local_1.LocalBuildMode.LOCAL_BUILD_PLUGIN) {
+            await (0, local_1.runLocalBuildAsync)(job, metadata, ctx.localBuildOptions, ctx.env);
+            return undefined;
+        }
+        else if (ctx.localBuildOptions.localBuildMode === local_1.LocalBuildMode.INTERNAL) {
+            await BuildMutation_1.BuildMutation.updateBuildMetadataAsync(ctx.graphqlClient, {
+                buildId: (0, nullthrows_1.default)(process.env.EAS_BUILD_ID),
+                metadata: (0, graphql_1.transformMetadata)({
+                    metadata,
+                    fingerprintSource: runtimeAndFingerprintMetadata.fingerprintSource ?? undefined,
+                }),
+            });
+            (0, json_1.printJsonOnlyOutput)({ job, metadata });
+            return undefined;
+        }
+        else if (!ctx.localBuildOptions.localBuildMode) {
+            try {
+                const graphqlMetadata = (0, graphql_1.transformMetadata)({
+                    metadata,
+                    fingerprintSource: runtimeAndFingerprintMetadata.fingerprintSource ?? undefined,
+                });
+                return await sendBuildRequestAsync(builder, job, graphqlMetadata, buildParams);
+            }
+            catch (error) {
+                handleBuildRequestError(error, job.platform);
+            }
+        }
+        else {
+            throw new Error('Unknown localBuildMode.');
+        }
+    };
+}
+const SERVER_SIDE_DEFINED_ERRORS = {
+    TURTLE_DEPRECATED_JOB_FORMAT: errors_1.TurtleDeprecatedJobFormatError,
+    EAS_BUILD_FREE_TIER_DISABLED: errors_1.EasBuildFreeTierDisabledError,
+    EAS_BUILD_FREE_TIER_DISABLED_IOS: errors_1.EasBuildFreeTierDisabledIOSError,
+    EAS_BUILD_FREE_TIER_DISABLED_ANDROID: errors_1.EasBuildFreeTierDisabledAndroidError,
+    EAS_BUILD_FREE_TIER_LIMIT_EXCEEDED: errors_1.EasBuildFreeTierLimitExceededError,
+    EAS_BUILD_FREE_TIER_IOS_LIMIT_EXCEEDED: errors_1.EasBuildFreeTierIosLimitExceededError,
+    EAS_BUILD_RESOURCE_CLASS_NOT_AVAILABLE_IN_FREE_TIER: errors_1.EasBuildResourceClassNotAvailableInFreeTierError,
+    EAS_BUILD_LEGACY_RESOURCE_CLASS_NOT_AVAILABLE: errors_1.EasBuildLegacyResourceClassNotAvailableError,
+    VALIDATION_ERROR: errors_1.RequestValidationError,
+};
+function handleBuildRequestError(error, platform) {
+    log_1.default.debug(JSON.stringify(error.graphQLErrors, null, 2));
+    const graphQLErrorCode = error?.graphQLErrors?.[0]?.extensions?.errorCode;
+    if (graphQLErrorCode in SERVER_SIDE_DEFINED_ERRORS) {
+        const ErrorClass = SERVER_SIDE_DEFINED_ERRORS[graphQLErrorCode];
+        throw new ErrorClass(error?.graphQLErrors?.[0]?.message);
+    }
+    else if (graphQLErrorCode === 'EAS_BUILD_DOWN_FOR_MAINTENANCE') {
+        throw new errors_1.EasBuildDownForMaintenanceError(`EAS Build is down for maintenance. Try again later. Check ${(0, log_1.link)('https://status.expo.dev/')} for updates.`);
+    }
+    else if (graphQLErrorCode === 'EAS_BUILD_TOO_MANY_PENDING_BUILDS') {
+        throw new errors_1.EasBuildTooManyPendingBuildsError(`You have already reached the maximum number of pending ${platform_1.requestedPlatformDisplayNames[platform]} builds for your account. Try again later.`);
+    }
+    else if (error?.graphQLErrors) {
+        const errorMessage = error.graphQLErrors
+            .map((graphQLError) => {
+            const requestIdLine = graphQLError?.extensions?.requestId
+                ? `\nRequest ID: ${graphQLError.extensions.requestId}`
+                : '';
+            const errorMessageLine = graphQLError?.message
+                ? `\nError message: ${graphQLError.message}`
+                : '';
+            return `${requestIdLine}${errorMessageLine}`;
+        })
+            .join('');
+        throw new Error(`Build request failed. Make sure you are using the latest eas-cli version. If the problem persists, report the issue.${errorMessage}`);
+    }
+    throw error;
+}
+async function uploadProjectAsync(ctx) {
+    let projectTarballPath;
+    try {
+        return await (0, common_1.withAnalyticsAsync)(ctx.analytics, async () => {
+            log_1.default.newLine();
+            log_1.default.log(`Compressing project files and uploading to EAS Build. ${(0, log_1.learnMore)('https://expo.fyi/eas-build-archive')}`);
+            const projectTarball = await (0, repository_1.makeProjectTarballAsync)(ctx.vcsClient);
+            (0, repository_1.maybeWarnAboutProjectTarballSize)(projectTarball.size);
+            (0, repository_1.assertProjectTarballSizeDoesNotExceedLimit)(projectTarball.size);
+            projectTarballPath = projectTarball.path;
+            const [bucketKey, { metadataLocation }] = await Promise.all([
+                (0, uploads_1.uploadFileAtPathToGCSAsync)(ctx.graphqlClient, generated_1.UploadSessionType.EasBuildGcsProjectSources, projectTarball.path, (0, progress_1.createProgressTracker)({
+                    total: projectTarball.size,
+                    message: ratio => `Uploading to EAS Build (${(0, files_1.formatBytes)(projectTarball.size * ratio)} / ${(0, files_1.formatBytes)(projectTarball.size)})`,
+                    completedMessage: (duration) => `Uploaded to EAS ${chalk_1.default.dim(duration)}`,
+                })),
+                uploadMetadataFileAsync(projectTarball, ctx),
+            ]);
+            if (metadataLocation) {
+                return { bucketKey, metadataLocation };
+            }
+            return { bucketKey };
+        }, {
+            attemptEvent: AnalyticsManager_1.BuildEvent.PROJECT_UPLOAD_ATTEMPT,
+            successEvent: AnalyticsManager_1.BuildEvent.PROJECT_UPLOAD_SUCCESS,
+            failureEvent: AnalyticsManager_1.BuildEvent.PROJECT_UPLOAD_FAIL,
+            properties: ctx.analyticsEventProperties,
+        });
+    }
+    catch (err) {
+        let errMessage = 'Failed to upload the project tarball to EAS Build';
+        if (err.message) {
+            errMessage += `\n\nReason: ${err.message}`;
+        }
+        throw new errors_1.EasBuildProjectArchiveUploadError(errMessage);
+    }
+    finally {
+        if (projectTarballPath) {
+            await fs_extra_1.default.remove(projectTarballPath);
+        }
+    }
+}
+async function uploadMetadataFileAsync(projectTarball, ctx) {
+    let projectMetadataFile = null;
+    try {
+        projectMetadataFile = await (0, repository_1.makeProjectMetadataFileAsync)(projectTarball.path);
+        const metadataLocation = await (0, uploads_1.uploadFileAtPathToGCSAsync)(ctx.graphqlClient, generated_1.UploadSessionType.EasBuildGcsProjectMetadata, projectMetadataFile.path);
+        return { metadataLocation };
+    }
+    catch (err) {
+        let errMessage = 'Failed to upload metadata to EAS Build';
+        if (err.message) {
+            errMessage += `\n\nReason: ${err.message}`;
+        }
+        log_1.default.warn(errMessage);
+        return { metadataLocation: null };
+    }
+    finally {
+        if (projectMetadataFile) {
+            await fs_extra_1.default.remove(projectMetadataFile.path);
+        }
+    }
+}
+async function sendBuildRequestAsync(builder, job, graphqlMetadata, buildParams) {
+    const { ctx } = builder;
+    return await (0, common_1.withAnalyticsAsync)(ctx.analytics, async () => {
+        if (log_1.default.isDebug) {
+            log_1.default.log(`Starting ${platform_1.requestedPlatformDisplayNames[job.platform]} build`);
+        }
+        const { build, deprecationInfo } = await builder.sendBuildRequestAsync(ctx.projectId, job, graphqlMetadata, buildParams);
+        (0, printBuildInfo_1.printDeprecationWarnings)(deprecationInfo);
+        return build;
+    }, {
+        attemptEvent: AnalyticsManager_1.BuildEvent.BUILD_REQUEST_ATTEMPT,
+        successEvent: AnalyticsManager_1.BuildEvent.BUILD_REQUEST_SUCCESS,
+        failureEvent: AnalyticsManager_1.BuildEvent.BUILD_REQUEST_FAIL,
+        properties: ctx.analyticsEventProperties,
+    });
+}
+async function waitForBuildEndAsync(graphqlClient, { buildIds, accountName }, { intervalSec = 10 } = {}) {
+    let spinner;
+    let originalSpinnerText;
+    if (buildIds.length === 1) {
+        log_1.default.log('Waiting for build to complete. You can press Ctrl+C to exit.');
+        originalSpinnerText = 'Waiting for build to complete.';
+        spinner = (0, ora_1.ora)(originalSpinnerText).start();
+    }
+    else {
+        originalSpinnerText = 'Waiting for builds to complete. You can press Ctrl+C to exit.';
+        spinner = (0, ora_1.ora)('Waiting for builds to complete. You can press Ctrl+C to exit.').start();
+    }
+    while (true) {
+        const builds = await getBuildsSafelyAsync(graphqlClient, buildIds);
+        const { refetch } = builds.length === 1
+            ? await handleSingleBuildProgressAsync({ build: builds[0], accountName }, { spinner })
+            : await handleMultipleBuildsProgressAsync({ builds }, { spinner, originalSpinnerText });
+        if (!refetch) {
+            return builds;
+        }
+        await (0, promise_1.sleepAsync)(intervalSec * 1000);
+    }
+}
+async function getBuildsSafelyAsync(graphqlClient, buildIds) {
+    const promises = buildIds.map(async (buildId) => {
+        try {
+            return await BuildQuery_1.BuildQuery.byIdAsync(graphqlClient, buildId, { useCache: false });
+        }
+        catch (err) {
+            log_1.default.debug('Failed to fetch the build status', err);
+            return null;
+        }
+    });
+    return await Promise.all(promises);
+}
+let queueProgressBarStarted = false;
+const queueProgressBar = new cli_progress_1.default.SingleBar({ format: '|{bar}| {estimatedWaitTime}' }, cli_progress_1.default.Presets.rect);
+let statusNewSetAt = null;
+const NEW_STATUS_GRACE_PERIOD_MS = 15_000;
+async function handleSingleBuildProgressAsync({ build, accountName, }, { spinner }) {
+    if (build === null) {
+        spinner.text = 'Could not fetch the build status. Check your network connection.';
+        return { refetch: true };
+    }
+    if (queueProgressBarStarted && build?.status && build.status !== generated_1.BuildStatus.InQueue) {
+        if (build.status === generated_1.BuildStatus.InProgress) {
+            queueProgressBar.update(queueProgressBar.getTotal(), {
+                estimatedWaitTime: '',
+            });
+        }
+        queueProgressBar.stop();
+        log_1.default.newLine();
+        queueProgressBarStarted = false;
+        spinner.start('Build is about to start');
+    }
+    switch (build.status) {
+        case generated_1.BuildStatus.Finished:
+            spinner.succeed('Build finished');
+            return { refetch: false };
+        case generated_1.BuildStatus.New: {
+            const now = Date.now();
+            statusNewSetAt ??= now;
+            const newStatusDurationMs = now - statusNewSetAt;
+            if (newStatusDurationMs < NEW_STATUS_GRACE_PERIOD_MS) {
+                spinner.text = 'Waiting for build to get enqueued…';
+            }
+            else {
+                spinner.text = `Build concurrency limit reached for your account. Build will enter queue once a concurrency becomes available. Add additional concurrencies at ${(0, log_1.link)(formatAccountBillingUrl(accountName))}.`;
+            }
+            break;
+        }
+        case generated_1.BuildStatus.InQueue: {
+            spinner.text = 'Build queued...';
+            const progressBarPayload = typeof build.estimatedWaitTimeLeftSeconds === 'number'
+                ? { estimatedWaitTime: formatEstimatedWaitTime(build.estimatedWaitTimeLeftSeconds) }
+                : { estimatedWaitTime: '' };
+            if (!queueProgressBarStarted &&
+                typeof build.initialQueuePosition === 'number' &&
+                typeof build.queuePosition === 'number' &&
+                typeof build.estimatedWaitTimeLeftSeconds === 'number') {
+                spinner.stopAndPersist();
+                if (build.priority !== generated_1.BuildPriority.High) {
+                    log_1.default.newLine();
+                    log_1.default.log('Start builds sooner in the priority queue.');
+                    log_1.default.log(`Sign up for a paid plan at ${(0, log_1.link)(formatAccountBillingUrl(accountName))}`);
+                }
+                log_1.default.newLine();
+                log_1.default.log(`Waiting in ${priorityToQueueDisplayName[build.priority]}`);
+                queueProgressBar.start(build.initialQueuePosition + 1, build.initialQueuePosition - build.queuePosition + 1, progressBarPayload);
+                queueProgressBarStarted = true;
+            }
+            if (typeof build.queuePosition === 'number') {
+                queueProgressBar.update(build.queuePosition, progressBarPayload);
+            }
+            break;
+        }
+        case generated_1.BuildStatus.PendingCancel:
+        case generated_1.BuildStatus.Canceled:
+            spinner.fail('Build canceled');
+            return { refetch: false };
+        case generated_1.BuildStatus.InProgress:
+            spinner.text = 'Build in progress...';
+            break;
+        case generated_1.BuildStatus.Errored:
+            spinner.fail('Build failed');
+            if (build.error) {
+                return { refetch: false };
+            }
+            else {
+                throw new Error('Standalone build failed!');
+            }
+        default:
+            spinner.warn('Unknown status');
+            throw new Error(`Unknown build status: ${build.status} - aborting!`);
+    }
+    return { refetch: true };
+}
+const priorityToQueueDisplayName = {
+    [generated_1.BuildPriority.Normal]: 'Free tier queue',
+    [generated_1.BuildPriority.NormalPlus]: 'Free tier queue',
+    [generated_1.BuildPriority.High]: 'priority queue',
+};
+const statusToDisplayName = {
+    [generated_1.BuildStatus.New]: 'waiting to enter the queue',
+    [generated_1.BuildStatus.InQueue]: 'in queue',
+    [generated_1.BuildStatus.InProgress]: 'in progress',
+    [generated_1.BuildStatus.PendingCancel]: 'canceled',
+    [generated_1.BuildStatus.Canceled]: 'canceled',
+    [generated_1.BuildStatus.Finished]: 'finished',
+    [generated_1.BuildStatus.Errored]: 'failed',
+};
+const platforms = [generated_1.AppPlatform.Android, generated_1.AppPlatform.Ios];
+async function handleMultipleBuildsProgressAsync({ builds: maybeBuilds }, { spinner, originalSpinnerText }) {
+    const buildCount = maybeBuilds.length;
+    const builds = maybeBuilds.filter(isBuildFragment);
+    const someNew = builds.some(build => build.status === generated_1.BuildStatus.New);
+    const allFinished = builds.filter(build => build.status === generated_1.BuildStatus.Finished).length === buildCount;
+    const allSettled = builds.filter(build => [
+        generated_1.BuildStatus.Finished,
+        generated_1.BuildStatus.Errored,
+        generated_1.BuildStatus.Canceled,
+        generated_1.BuildStatus.PendingCancel,
+    ].includes(build.status)).length === buildCount;
+    if (someNew && statusNewSetAt === null) {
+        statusNewSetAt = Date.now();
+    }
+    if (allSettled) {
+        if (allFinished) {
+            spinner.succeed(formatSettledBuildsText(builds));
+        }
+        else {
+            spinner.fail(formatSettledBuildsText(builds));
+        }
+        return { refetch: false };
+    }
+    else {
+        const showConcurrencyWarning = someNew &&
+            statusNewSetAt !== null &&
+            Date.now() - statusNewSetAt >= NEW_STATUS_GRACE_PERIOD_MS;
+        spinner.text = formatPendingBuildsText(originalSpinnerText, builds, showConcurrencyWarning);
+        return { refetch: true };
+    }
+}
+function formatSettledBuildsText(builds) {
+    return platforms
+        .map(platform => {
+        const build = (0, nullthrows_1.default)(builds.find(build => build.platform === platform), `Build for platform ${platform} must be defined in this context`);
+        return `${platform_1.appPlatformEmojis[platform]} ${platform_1.appPlatformDisplayNames[platform]} build - status: ${chalk_1.default.bold(statusToDisplayName[build.status])}`;
+    })
+        .join('\n  ');
+}
+function formatPendingBuildsText(originalSpinnerText, builds, showConcurrencyWarning) {
+    return [
+        originalSpinnerText,
+        ...platforms.map(platform => {
+            const build = builds.find(build => build.platform === platform);
+            const status = build ? statusToDisplayName[build.status] : 'unknown';
+            const concurrencyWarning = showConcurrencyWarning && build?.status === generated_1.BuildStatus.New
+                ? ' (concurrency limit reached)'
+                : '';
+            let extraInfo = '';
+            if (build?.status === generated_1.BuildStatus.InQueue &&
+                typeof build.initialQueuePosition === 'number' &&
+                typeof build.queuePosition === 'number') {
+                const percent = Math.floor(((build.initialQueuePosition - build.queuePosition + 1) /
+                    (build.initialQueuePosition + 1)) *
+                    100);
+                const estimatedWaitTime = typeof build.estimatedWaitTimeLeftSeconds === 'number'
+                    ? ` - ${formatEstimatedWaitTime(build.estimatedWaitTimeLeftSeconds)}`
+                    : '';
+                extraInfo = ` - queue progress: ${chalk_1.default.bold(`${percent}%`)}${estimatedWaitTime}`;
+            }
+            return `${platform_1.appPlatformEmojis[platform]} ${platform_1.appPlatformDisplayNames[platform]} build - status: ${chalk_1.default.bold(status)}${concurrencyWarning}${extraInfo}`;
+        }),
+    ].join('\n  ');
+}
+function isBuildFragment(maybeBuild) {
+    return maybeBuild !== null;
+}
+function formatEstimatedWaitTime(estimatedWaitTimeLeftSeconds) {
+    if (estimatedWaitTimeLeftSeconds < 5 * 60) {
+        return 'starting soon...';
+    }
+    else {
+        const n = Math.floor(estimatedWaitTimeLeftSeconds / (10 * 60)) + 1;
+        return `starting in about ${n}0 minutes...`;
+    }
+}
+function formatAccountBillingUrl(accountName) {
+    return new URL(`/accounts/${accountName}/settings/billing`, (0, api_1.getExpoWebsiteBaseUrl)()).toString();
+}
+async function computeAndMaybeUploadRuntimeAndFingerprintMetadataAsync(ctx) {
+    const runtimeAndFingerprintMetadata = await computeAndMaybeUploadFingerprintFromExpoUpdatesAsync(ctx);
+    if (!runtimeAndFingerprintMetadata?.fingerprintHash) {
+        const fingerprint = await computeAndMaybeUploadFingerprintWithoutExpoUpdatesAsync(ctx);
+        return {
+            ...runtimeAndFingerprintMetadata,
+            ...fingerprint,
+        };
+    }
+    else {
+        return {
+            ...runtimeAndFingerprintMetadata,
+            fingerprintHash: runtimeAndFingerprintMetadata.runtimeVersion,
+        };
+    }
+}
+async function computeAndMaybeUploadFingerprintFromExpoUpdatesAsync(ctx) {
+    const resolvedRuntimeVersion = await (0, resolveRuntimeVersionAsync_1.resolveRuntimeVersionAsync)({
+        exp: ctx.exp,
+        platform: ctx.platform,
+        workflow: ctx.workflow,
+        projectDir: ctx.projectDir,
+        env: ctx.env,
+        cwd: ctx.projectDir,
+    });
+    if (!resolvedRuntimeVersion) {
+        return {};
+    }
+    /**
+     * It's ok for fingerprintSources or runtimeVersion to be empty
+     * fingerprintSources only exist if the project is using runtimeVersion.policy: fingerprint
+     */
+    if (!resolvedRuntimeVersion.expoUpdatesRuntimeFingerprint ||
+        !resolvedRuntimeVersion.runtimeVersion) {
+        return {
+            runtimeVersion: resolvedRuntimeVersion.runtimeVersion ?? undefined,
+        };
+    }
+    const uploadedFingerprint = await (0, maybeUploadFingerprintAsync_1.maybeUploadFingerprintAsync)({
+        hash: resolvedRuntimeVersion.runtimeVersion,
+        fingerprint: resolvedRuntimeVersion.expoUpdatesRuntimeFingerprint,
+        graphqlClient: ctx.graphqlClient,
+        localBuildMode: ctx.localBuildOptions.localBuildMode,
+    });
+    return {
+        runtimeVersion: uploadedFingerprint.hash,
+        fingerprintSource: uploadedFingerprint.fingerprintSource,
+        fingerprintHash: resolvedRuntimeVersion.expoUpdatesRuntimeFingerprintHash ?? undefined,
+    };
+}
+async function computeAndMaybeUploadFingerprintWithoutExpoUpdatesAsync(ctx, { debug } = {}) {
+    const fingerprint = await (0, cli_1.createFingerprintAsync)(ctx.projectDir, {
+        workflow: ctx.workflow,
+        platforms: [ctx.platform],
+        env: ctx.env,
+    });
+    if (!fingerprint) {
+        return {};
+    }
+    const uploadedFingerprint = await (0, maybeUploadFingerprintAsync_1.maybeUploadFingerprintAsync)({
+        hash: fingerprint.hash,
+        fingerprint: {
+            fingerprintSources: fingerprint.sources,
+            isDebugFingerprintSource: debug ?? false,
+        },
+        graphqlClient: ctx.graphqlClient,
+        localBuildMode: ctx.localBuildOptions.localBuildMode,
+    });
+    return {
+        fingerprintHash: uploadedFingerprint.hash,
+        fingerprintSource: uploadedFingerprint.fingerprintSource,
+    };
+}

package/build/build/configure.d.ts

@@ -0,0 +1,27 @@
+import { Client } from '../vcs/vcs';
+interface ConfigureParams {
+    projectDir: string;
+    nonInteractive: boolean;
+    vcsClient: Client;
+}
+export declare function easJsonExistsAsync(projectDir: string): Promise<boolean>;
+/**
+ * Creates eas.json if it does not exist.
+ *
+ * Returns:
+ * - false - if eas.json already exists
+ * - true - if eas.json was created by the function
+ */
+export declare function ensureProjectConfiguredAsync(configureParams: ConfigureParams): Promise<boolean>;
+export declare function doesBuildProfileExistAsync({ projectDir, profileName, }: {
+    projectDir: string;
+    profileName: string;
+}): Promise<boolean>;
+export declare function createBuildProfileAsync({ projectDir, profileName, profileContents, vcsClient, nonInteractive, }: {
+    projectDir: string;
+    profileName: string;
+    profileContents: Record<string, any>;
+    vcsClient: Client;
+    nonInteractive: boolean;
+}): Promise<void>;
+export {};

package/build/build/configure.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.easJsonExistsAsync = easJsonExistsAsync;
+exports.ensureProjectConfiguredAsync = ensureProjectConfiguredAsync;
+exports.doesBuildProfileExistAsync = doesBuildProfileExistAsync;
+exports.createBuildProfileAsync = createBuildProfileAsync;
+const tslib_1 = require("tslib");
+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 repository_1 = require("./utils/repository");
+const log_1 = tslib_1.__importStar(require("../log"));
+const ora_1 = require("../ora");
+const easCli_1 = require("../utils/easCli");
+async function easJsonExistsAsync(projectDir) {
+    return await fs_extra_1.default.pathExists(eas_json_1.EasJsonAccessor.formatEasJsonPath(projectDir));
+}
+/**
+ * Creates eas.json if it does not exist.
+ *
+ * Returns:
+ * - false - if eas.json already exists
+ * - true - if eas.json was created by the function
+ */
+async function ensureProjectConfiguredAsync(configureParams) {
+    if (await easJsonExistsAsync(configureParams.projectDir)) {
+        return false;
+    }
+    await configureAsync(configureParams);
+    return true;
+}
+async function configureAsync({ projectDir, nonInteractive, vcsClient, }) {
+    await (0, repository_1.maybeBailOnRepoStatusAsync)(vcsClient, nonInteractive);
+    await createEasJsonAsync(projectDir, vcsClient);
+    if (await vcsClient.isCommitRequiredAsync()) {
+        log_1.default.newLine();
+        await (0, repository_1.reviewAndCommitChangesAsync)(vcsClient, 'Configure EAS Build', {
+            nonInteractive,
+        });
+    }
+}
+async function doesBuildProfileExistAsync({ projectDir, profileName, }) {
+    try {
+        const easJsonAccessor = eas_json_1.EasJsonAccessor.fromProjectPath(projectDir);
+        const easJson = await easJsonAccessor.readRawJsonAsync();
+        if (!easJson.build?.[profileName]) {
+            return false;
+        }
+        return true;
+    }
+    catch (error) {
+        log_1.default.error(`We were unable to read ${chalk_1.default.bold('eas.json')} contents. Error: ${error}.`);
+        throw error;
+    }
+}
+async function createBuildProfileAsync({ projectDir, profileName, profileContents, vcsClient, nonInteractive, }) {
+    const spinner = (0, ora_1.ora)(`Adding "${profileName}" build profile to ${chalk_1.default.bold('eas.json')}`).start();
+    try {
+        const easJsonAccessor = eas_json_1.EasJsonAccessor.fromProjectPath(projectDir);
+        await easJsonAccessor.readRawJsonAsync();
+        easJsonAccessor.patch(easJsonRawObject => {
+            return {
+                ...easJsonRawObject,
+                build: {
+                    ...easJsonRawObject.build,
+                    [profileName]: profileContents,
+                },
+            };
+        });
+        await easJsonAccessor.writeAsync();
+        spinner.succeed(`Successfully added "${profileName}" build profile to ${chalk_1.default.bold('eas.json')}.`);
+        if (await vcsClient.isCommitRequiredAsync()) {
+            log_1.default.newLine();
+            await (0, repository_1.reviewAndCommitChangesAsync)(vcsClient, `Add "${profileName}" build profile to eas.json`, {
+                nonInteractive,
+            });
+        }
+    }
+    catch (error) {
+        spinner.fail(`We were not able to configure "${profileName}" build profile inside of ${chalk_1.default.bold('eas.json')}. Error: ${error}.`);
+        throw error;
+    }
+}
+const EAS_JSON_DEFAULT = {
+    cli: {
+        version: `>= ${easCli_1.easCliVersion}`,
+        appVersionSource: eas_json_1.AppVersionSource.REMOTE,
+    },
+    build: {
+        development: {
+            developmentClient: true,
+            distribution: 'internal',
+        },
+        preview: {
+            distribution: 'internal',
+        },
+        production: {
+            autoIncrement: true,
+        },
+    },
+    submit: {
+        production: {},
+    },
+};
+async function createEasJsonAsync(projectDir, vcsClient) {
+    const easJsonPath = eas_json_1.EasJsonAccessor.formatEasJsonPath(projectDir);
+    await fs_extra_1.default.writeFile(easJsonPath, `${JSON.stringify(EAS_JSON_DEFAULT, null, 2)}\n`);
+    await vcsClient.trackFileAsync(easJsonPath);
+    log_1.default.withTick(`Generated ${chalk_1.default.bold('eas.json')}. ${(0, log_1.learnMore)('https://docs.expo.dev/build-reference/eas-json/')}`);
+}