eas-cli 0.38.1 → 0.40.0

package/build/commands/update/index.d.ts

@@ -0,0 +1,20 @@
+import { flags } from '@oclif/command';
+import EasCommand from '../../commandUtils/EasCommand';
+import { PublishPlatform } from '../../project/publish';
+export declare const defaultPublishPlatforms: PublishPlatform[];
+export default class UpdatePublish extends EasCommand {
+    static hidden: boolean;
+    static description: string;
+    static flags: {
+        branch: flags.IOptionFlag<string | undefined>;
+        message: flags.IOptionFlag<string | undefined>;
+        republish: import("@oclif/parser/lib/flags").IBooleanFlag<boolean>;
+        group: flags.IOptionFlag<string | undefined>;
+        'input-dir': flags.IOptionFlag<string>;
+        'skip-bundler': import("@oclif/parser/lib/flags").IBooleanFlag<boolean>;
+        platform: flags.IOptionFlag<string>;
+        json: import("@oclif/parser/lib/flags").IBooleanFlag<boolean>;
+        auto: import("@oclif/parser/lib/flags").IBooleanFlag<boolean>;
+    };
+    runAsync(): Promise<void>;
+}

package/build/commands/update/index.js

@@ -0,0 +1,361 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultPublishPlatforms = void 0;
+const tslib_1 = require("tslib");
+const config_1 = require("@expo/config");
+const config_plugins_1 = require("@expo/config-plugins");
+const eas_build_job_1 = require("@expo/eas-build-job");
+const command_1 = require("@oclif/command");
+const assert_1 = (0, tslib_1.__importDefault)(require("assert"));
+const chalk_1 = (0, tslib_1.__importDefault)(require("chalk"));
+const dateformat_1 = (0, tslib_1.__importDefault)(require("dateformat"));
+const graphql_tag_1 = (0, tslib_1.__importDefault)(require("graphql-tag"));
+const EasCommand_1 = (0, tslib_1.__importDefault)(require("../../commandUtils/EasCommand"));
+const client_1 = require("../../graphql/client");
+const PublishMutation_1 = require("../../graphql/mutations/PublishMutation");
+const log_1 = (0, tslib_1.__importDefault)(require("../../log"));
+const ora_1 = require("../../ora");
+const projectUtils_1 = require("../../project/projectUtils");
+const publish_1 = require("../../project/publish");
+const workflow_1 = require("../../project/workflow");
+const prompts_1 = require("../../prompts");
+const utils_1 = require("../../update/utils");
+const uniqBy_1 = (0, tslib_1.__importDefault)(require("../../utils/expodash/uniqBy"));
+const formatFields_1 = (0, tslib_1.__importDefault)(require("../../utils/formatFields"));
+const vcs_1 = require("../../vcs");
+const create_1 = require("../branch/create");
+const list_1 = require("../branch/list");
+const view_1 = require("../branch/view");
+const create_2 = require("../channel/create");
+const configure_1 = require("./configure");
+exports.defaultPublishPlatforms = ['android', 'ios'];
+async function getUpdateGroupAsync({ group, }) {
+    const { updatesByGroup } = await (0, client_1.withErrorHandlingAsync)(client_1.graphqlClient
+        .query((0, graphql_tag_1.default) `
+          query getUpdateGroupAsync($group: ID!) {
+            updatesByGroup(group: $group) {
+              id
+              group
+              runtimeVersion
+              manifestFragment
+              platform
+              message
+            }
+          }
+        `, {
+        group,
+    }, { additionalTypenames: ['Update'] })
+        .toPromise());
+    return updatesByGroup;
+}
+async function ensureChannelExistsAsync({ appId, branchId, channelName, }) {
+    var _a;
+    try {
+        await (0, create_2.createUpdateChannelOnAppAsync)({
+            appId,
+            channelName,
+            branchId,
+        });
+        log_1.default.withTick(`Created a channel: ${chalk_1.default.bold(channelName)} pointed at branch: ${chalk_1.default.bold(channelName)}.`);
+    }
+    catch (e) {
+        const isIgnorableError = ((_a = e.graphQLErrors) === null || _a === void 0 ? void 0 : _a.length) === 1 &&
+            e.graphQLErrors[0].extensions.errorCode === 'CHANNEL_ALREADY_EXISTS';
+        if (!isIgnorableError) {
+            throw e;
+        }
+    }
+}
+async function ensureBranchExistsAsync({ appId, name: branchName, }) {
+    const { app } = await (0, view_1.viewUpdateBranchAsync)({
+        appId,
+        name: branchName,
+    });
+    const updateBranch = app === null || app === void 0 ? void 0 : app.byId.updateBranchByName;
+    if (updateBranch) {
+        const { id, updates } = updateBranch;
+        await ensureChannelExistsAsync({ appId, branchId: id, channelName: branchName });
+        return { id, updates };
+    }
+    const newUpdateBranch = await (0, create_1.createUpdateBranchOnAppAsync)({ appId, name: branchName });
+    log_1.default.withTick(`Created branch: ${chalk_1.default.bold(branchName)}`);
+    await ensureChannelExistsAsync({ appId, branchId: newUpdateBranch.id, channelName: branchName });
+    return { id: newUpdateBranch.id, updates: [] };
+}
+class UpdatePublish extends EasCommand_1.default {
+    async runAsync() {
+        var _a, _b, _c;
+        let { flags: { branch: branchName, json: jsonFlag, auto: autoFlag, message, republish, group, 'input-dir': inputDir, 'skip-bundler': skipBundler, }, } = this.parse(UpdatePublish);
+        const platformFlag = this.parse(UpdatePublish).flags.platform;
+        // If a group was specified, that means we are republishing it.
+        republish = group ? true : republish;
+        const projectDir = await (0, projectUtils_1.findProjectRootAsync)();
+        const { exp } = (0, config_1.getConfig)(projectDir, {
+            skipSDKVersionRequirement: true,
+            isPublicConfig: true,
+        });
+        const runtimeVersions = await getRuntimeVersionObjectAsync(exp, platformFlag, projectDir);
+        const projectId = await (0, projectUtils_1.getProjectIdAsync)(exp);
+        await checkEASUpdateURLIsSetAsync(exp);
+        if (!branchName && autoFlag) {
+            branchName =
+                (await (0, vcs_1.getVcsClient)().getBranchNameAsync()) ||
+                    `branch-${Math.random().toString(36).substr(2, 4)}`;
+        }
+        if (!branchName) {
+            const validationMessage = 'branch name may not be empty.';
+            if (jsonFlag) {
+                throw new Error(validationMessage);
+            }
+            const branches = await (0, list_1.listBranchesAsync)({ projectId });
+            branchName = await (0, prompts_1.selectAsync)('which branch would you like to publish on?', branches.map(branch => {
+                return {
+                    title: `${branch.name} ${chalk_1.default.grey(`- current update: ${(0, utils_1.formatUpdate)(branch.updates[0])}`)}`,
+                    value: branch.name,
+                };
+            }));
+            (0, assert_1.default)(branchName, 'branch name must be specified.');
+        }
+        const { id: branchId, updates } = await ensureBranchExistsAsync({
+            appId: projectId,
+            name: branchName,
+        });
+        let unsortedUpdateInfoGroups = {};
+        let oldMessage, oldRuntimeVersion;
+        if (republish) {
+            // If we are republishing, we don't need to worry about building the bundle or uploading the assets.
+            // Instead we get the `updateInfoGroup` from the update we wish to republish.
+            let updatesToRepublish;
+            if (group) {
+                updatesToRepublish = await getUpdateGroupAsync({ group });
+            }
+            else {
+                // Drop into interactive mode if the user has not specified an update group to republish.
+                if (jsonFlag) {
+                    throw new Error('You must specify the update group to republish.');
+                }
+                const updateGroups = (0, uniqBy_1.default)(updates, u => u.group)
+                    .filter(update => {
+                    // Only show groups that have updates on the specified platform(s).
+                    return platformFlag === 'all' || update.platform === platformFlag;
+                })
+                    .map(update => ({
+                    title: formatUpdateTitle(update),
+                    value: update.group,
+                }));
+                if (updateGroups.length === 0) {
+                    throw new Error(`There are no updates on branch "${branchName}" published on the platform(s) ${platformFlag}. Did you mean to publish a new update instead?`);
+                }
+                const selectedUpdateGroup = await (0, prompts_1.selectAsync)('which update would you like to republish?', updateGroups);
+                updatesToRepublish = updates.filter(update => update.group === selectedUpdateGroup);
+            }
+            const updatesToRepublishFilteredByPlatform = updatesToRepublish.filter(
+            // Only republish to the specified platforms
+            update => platformFlag === 'all' || update.platform === platformFlag);
+            if (updatesToRepublishFilteredByPlatform.length === 0) {
+                throw new Error(`There are no updates on branch "${branchName}" published on the platform(s) "${platformFlag}" with group ID "${group ? group : updatesToRepublish[0].group}". Did you mean to publish a new update instead?`);
+            }
+            let publicationPlatformMessage;
+            if (platformFlag === 'all') {
+                if (updatesToRepublishFilteredByPlatform.length !== exports.defaultPublishPlatforms.length) {
+                    log_1.default.warn(`You are republishing an update that wasn't published for all platforms.`);
+                }
+                publicationPlatformMessage = `The republished update will appear on the same plaforms it was originally published on: ${updatesToRepublishFilteredByPlatform
+                    .map(update => update.platform)
+                    .join(',')}`;
+            }
+            else {
+                publicationPlatformMessage = `The republished update will appear only on: ${platformFlag}`;
+            }
+            log_1.default.withTick(publicationPlatformMessage);
+            for (const update of updatesToRepublishFilteredByPlatform) {
+                const { manifestFragment } = update;
+                const platform = update.platform;
+                unsortedUpdateInfoGroups[platform] = JSON.parse(manifestFragment);
+            }
+            // These are the same for each member of an update group
+            group = updatesToRepublishFilteredByPlatform[0].group;
+            oldMessage = (_a = updatesToRepublishFilteredByPlatform[0].message) !== null && _a !== void 0 ? _a : '';
+            oldRuntimeVersion = updatesToRepublishFilteredByPlatform[0].runtimeVersion;
+        }
+        else {
+            if (!message && autoFlag) {
+                message = (_b = (await (0, vcs_1.getVcsClient)().getLastCommitMessageAsync())) === null || _b === void 0 ? void 0 : _b.trim();
+            }
+            if (!message) {
+                const validationMessage = 'publish message may not be empty.';
+                if (jsonFlag) {
+                    throw new Error(validationMessage);
+                }
+                ({ publishMessage: message } = await (0, prompts_1.promptAsync)({
+                    type: 'text',
+                    name: 'publishMessage',
+                    message: `Please enter an update message.`,
+                    initial: republish
+                        ? `Republish "${oldMessage}" - group: ${group}`
+                        : (_c = (await (0, vcs_1.getVcsClient)().getLastCommitMessageAsync())) === null || _c === void 0 ? void 0 : _c.trim(),
+                    validate: (value) => (value ? true : validationMessage),
+                }));
+            }
+            // build bundle and upload assets for a new publish
+            if (!skipBundler) {
+                await (0, publish_1.buildBundlesAsync)({ projectDir, inputDir });
+            }
+            const assetSpinner = (0, ora_1.ora)('Uploading assets...').start();
+            try {
+                const platforms = platformFlag === 'all' ? exports.defaultPublishPlatforms : [platformFlag];
+                const assets = await (0, publish_1.collectAssetsAsync)({ inputDir: inputDir, platforms });
+                await (0, publish_1.uploadAssetsAsync)(assets);
+                unsortedUpdateInfoGroups = await (0, publish_1.buildUnsortedUpdateInfoGroupAsync)(assets, exp);
+                assetSpinner.succeed('Uploaded assets!');
+            }
+            catch (e) {
+                assetSpinner.fail('Failed to upload assets');
+                throw e;
+            }
+        }
+        const runtimeToPlatformMapping = {};
+        for (const runtime of new Set(Object.values(runtimeVersions))) {
+            runtimeToPlatformMapping[runtime] = Object.entries(runtimeVersions)
+                .filter(pair => pair[1] === runtime)
+                .map(pair => pair[0]);
+        }
+        // Sort the updates into different groups based on their platform specific runtime versions
+        const updateGroups = Object.entries(runtimeToPlatformMapping).map(([runtime, platforms]) => {
+            const localUpdateInfoGroup = Object.fromEntries(platforms.map(platform => [
+                platform,
+                unsortedUpdateInfoGroups[platform],
+            ]));
+            if (republish && !oldRuntimeVersion) {
+                throw new Error('Can not find the runtime version of the update group that is being republished.');
+            }
+            return {
+                branchId,
+                updateInfoGroup: localUpdateInfoGroup,
+                runtimeVersion: republish ? oldRuntimeVersion : runtime,
+                message,
+            };
+        });
+        let newUpdates;
+        const publishSpinner = (0, ora_1.ora)('Publishing...').start();
+        try {
+            newUpdates = await PublishMutation_1.PublishMutation.publishUpdateGroupAsync(updateGroups);
+            publishSpinner.succeed('Published!');
+        }
+        catch (e) {
+            publishSpinner.fail('Failed to published updates');
+            throw e;
+        }
+        if (jsonFlag) {
+            log_1.default.log(JSON.stringify(newUpdates));
+        }
+        else {
+            if (new Set(newUpdates.map(update => update.group)).size > 1) {
+                log_1.default.addNewLineIfNone();
+                log_1.default.log('👉 Since multiple runtime versions are defined, multiple update groups have been published.');
+            }
+            log_1.default.addNewLineIfNone();
+            for (const runtime of new Set(Object.values(runtimeVersions))) {
+                const platforms = newUpdates
+                    .filter(update => update.runtimeVersion === runtime)
+                    .map(update => update.platform);
+                const newUpdate = newUpdates.find(update => update.runtimeVersion === runtime);
+                if (!newUpdate) {
+                    throw new Error(`Publish response is missing updates with runtime ${runtime}.`);
+                }
+                log_1.default.log((0, formatFields_1.default)([
+                    { label: 'branch', value: branchName },
+                    { label: 'runtime version', value: runtime },
+                    { label: 'platform', value: platforms.join(', ') },
+                    { label: 'update group ID', value: newUpdate.group },
+                    { label: 'message', value: message },
+                ]));
+                log_1.default.addNewLineIfNone();
+            }
+        }
+    }
+}
+exports.default = UpdatePublish;
+UpdatePublish.hidden = true;
+UpdatePublish.description = 'Publish an update group.';
+UpdatePublish.flags = {
+    branch: command_1.flags.string({
+        description: 'Branch to publish the update group on',
+        required: false,
+    }),
+    message: command_1.flags.string({
+        description: 'A short message describing the update',
+        required: false,
+    }),
+    republish: command_1.flags.boolean({
+        description: 'Republish an update group',
+        exclusive: ['input-dir', 'skip-bundler'],
+    }),
+    group: command_1.flags.string({
+        description: 'Update group to republish',
+        exclusive: ['input-dir', 'skip-bundler'],
+    }),
+    'input-dir': command_1.flags.string({
+        description: 'Location of the bundle',
+        default: 'dist',
+        required: false,
+    }),
+    'skip-bundler': command_1.flags.boolean({
+        description: `Skip running Expo CLI to bundle the app before publishing`,
+        default: false,
+    }),
+    platform: command_1.flags.enum({
+        char: 'p',
+        options: [...exports.defaultPublishPlatforms, 'all'],
+        default: 'all',
+        required: false,
+    }),
+    json: command_1.flags.boolean({
+        description: 'Enable JSON output, non-JSON messages will be printed to stderr',
+        default: false,
+    }),
+    auto: command_1.flags.boolean({
+        description: 'Use the current git branch and commit message for the EAS branch and update message',
+        default: false,
+    }),
+};
+async function getRuntimeVersionObjectAsync(exp, platformFlag, projectDir) {
+    var _a, _b;
+    const platforms = (platformFlag === 'all' ? ['android', 'ios'] : [platformFlag]);
+    for (const platform of platforms) {
+        const isPolicy = typeof ((_b = (_a = exp[platform]) === null || _a === void 0 ? void 0 : _a.runtimeVersion) !== null && _b !== void 0 ? _b : exp.runtimeVersion) === 'object';
+        if (isPolicy) {
+            const isManaged = (await (0, workflow_1.resolveWorkflowAsync)(projectDir, platform)) === eas_build_job_1.Workflow.MANAGED;
+            if (!isManaged) {
+                throw new Error('Runtime version policies are only supported in the managed workflow.');
+            }
+        }
+    }
+    return Object.fromEntries(platforms.map(platform => [platform, config_plugins_1.Updates.getRuntimeVersion(exp, platform)]));
+}
+function formatUpdateTitle(update) {
+    const { message, createdAt, actor, runtimeVersion } = update;
+    let actorName;
+    switch (actor === null || actor === void 0 ? void 0 : actor.__typename) {
+        case 'User': {
+            actorName = actor.username;
+            break;
+        }
+        case 'Robot': {
+            const { firstName, id } = actor;
+            actorName = firstName !== null && firstName !== void 0 ? firstName : `robot: ${id.slice(0, 4)}...`;
+            break;
+        }
+        default:
+            actorName = 'unknown';
+    }
+    return `[${(0, dateformat_1.default)(createdAt, 'mmm dd HH:MM')} by ${actorName}, runtimeVersion: ${runtimeVersion}] ${message}`;
+}
+async function checkEASUpdateURLIsSetAsync(exp) {
+    var _a;
+    const configuredURL = (_a = exp.updates) === null || _a === void 0 ? void 0 : _a.url;
+    const expectedURL = await (0, configure_1.getEASUpdateURLAsync)(exp);
+    if (configuredURL !== expectedURL) {
+        throw new Error(`The update URL is incorrectly configured for EAS Update. Please set updates.url to ${expectedURL} in your app.json.`);
+    }
+}

package/build/credentials/context.d.ts

@@ -1,4 +1,5 @@
 import { ExpoConfig } from '@expo/config';
+import { Env } from '@expo/eas-build-job';
 import { Actor } from '../user/User';
 import * as AndroidGraphqlClient from './android/api/GraphqlClient';
 import * as IosGraphqlClient from './ios/api/GraphqlClient';
@@ -18,7 +19,11 @@ export declare class CredentialsContext {
         nonInteractive?: boolean;
         projectDir: string;
         user: Actor;
+        env?: Env;
     });
+    static getExpoConfigInProject(projectDir: string, { env }?: {
+        env?: Env;
+    }): ExpoConfig | null;
     get hasProjectContext(): boolean;
     get exp(): ExpoConfig;
     ensureProjectContext(): void;

package/build/credentials/context.js

@@ -14,7 +14,7 @@ const IosGraphqlClient = (0, tslib_1.__importStar)(require("./ios/api/GraphqlCli
 const AppStoreApi_1 = (0, tslib_1.__importDefault)(require("./ios/appstore/AppStoreApi"));
 class CredentialsContext {
     constructor(options) {
-        var _a;
+        var _a, _b;
         this.options = options;
         this.android = AndroidGraphqlClient;
         this.appStore = new AppStoreApi_1.default();
@@ -25,12 +25,17 @@ class CredentialsContext {
         this.nonInteractive = (_a = options.nonInteractive) !== null && _a !== void 0 ? _a : false;
         this.resolvedExp = options.exp;
         if (!this.resolvedExp) {
-            try {
-                this.resolvedExp = (0, expoConfig_1.getExpoConfig)(options.projectDir);
-            }
-            catch (error) {
-                // ignore error, context might be created outside of expo project
-            }
+            this.resolvedExp =
+                (_b = CredentialsContext.getExpoConfigInProject(this.projectDir, { env: options.env })) !== null && _b !== void 0 ? _b : undefined;
+        }
+    }
+    static getExpoConfigInProject(projectDir, { env } = {}) {
+        try {
+            return (0, expoConfig_1.getExpoConfig)(projectDir, { env });
+        }
+        catch (error) {
+            // ignore error, context might be created outside of expo project
+            return null;
         }
     }
     get hasProjectContext() {

package/build/credentials/ios/actions/AscApiKeyUtils.js

@@ -93,7 +93,7 @@ async function promptForAscApiKeyAsync(ctx) {
 }
 async function promptForKeyP8AndIdAsync() {
     var _a, _b;
-    log_1.default.log(chalk_1.default.bold('An App Store Connect Api key is required to upload your app to the Apple App Store'));
+    log_1.default.log(chalk_1.default.bold('An App Store Connect Api key is required to upload your app to the Apple App Store Connect'));
     log_1.default.log(`If you're not sure what this is or how to create one, ${(0, log_1.learnMore)('https://expo.fyi/creating-asc-api-key')}`);
     const { keyP8Path } = await (0, prompts_1.promptAsync)({
         type: 'text',

package/build/credentials/ios/appstore/ensureAppExists.js

@@ -96,10 +96,10 @@ exports.syncCapabilityIdentifiersAsync = syncCapabilityIdentifiersAsync;
 async function ensureAppExistsAsync(authCtx, { name, language, companyName, bundleIdentifier, sku, }) {
     var _a;
     const context = (0, authenticate_1.getRequestContext)(authCtx);
-    const spinner = (0, ora_1.ora)(`Linking to App Store ${chalk_1.default.dim(bundleIdentifier)}`).start();
+    const spinner = (0, ora_1.ora)(`Linking to App Store Connect ${chalk_1.default.dim(bundleIdentifier)}`).start();
     let app = await apple_utils_1.App.findAsync(context, { bundleId: bundleIdentifier });
     if (!app) {
-        spinner.text = `Creating App Store app ${chalk_1.default.bold(name)} ${chalk_1.default.dim(bundleIdentifier)}`;
+        spinner.text = `Creating App Store Connect app ${chalk_1.default.bold(name)} ${chalk_1.default.dim(bundleIdentifier)}`;
         try {
             // Assert contract errors when the user needs to create an app.
             await (0, contractMessages_1.assertContractMessagesAsync)(context, spinner);
@@ -125,7 +125,7 @@ async function ensureAppExistsAsync(authCtx, { name, language, companyName, bund
     else {
         // TODO: Update app name when API gives us that possibility
     }
-    spinner.succeed(`Prepared App Store for ${chalk_1.default.bold(name)} ${chalk_1.default.dim(bundleIdentifier)}`);
+    spinner.succeed(`Prepared App Store Connect for ${chalk_1.default.bold(name)} ${chalk_1.default.dim(bundleIdentifier)}`);
     return app;
 }
 exports.ensureAppExistsAsync = ensureAppExistsAsync;

package/build/credentials/manager/ManageAndroid.d.ts

@@ -1,10 +1,10 @@
-import { CredentialsContext } from '../context';
 import { ActionInfo } from './Actions';
 import { Action } from './HelperActions';
 export declare class ManageAndroid {
     private callingAction;
-    constructor(callingAction: Action);
-    runAsync(ctx: CredentialsContext, currentActions?: ActionInfo[]): Promise<void>;
+    private projectDir;
+    constructor(callingAction: Action, projectDir: string);
+    runAsync(currentActions?: ActionInfo[]): Promise<void>;
     private createProjectContextAsync;
     private runProjectSpecificActionAsync;
 }

package/build/credentials/manager/ManageAndroid.js

@@ -25,16 +25,27 @@ const SetUpGoogleServiceAccountKey_1 = require("../android/actions/SetUpGoogleSe
 const UpdateCredentialsJson_1 = require("../android/actions/UpdateCredentialsJson");
 const UseExistingGoogleServiceAccountKey_1 = require("../android/actions/UseExistingGoogleServiceAccountKey");
 const printCredentials_1 = require("../android/utils/printCredentials");
+const context_1 = require("../context");
 const Actions_1 = require("./Actions");
 const AndroidActions_1 = require("./AndroidActions");
 const HelperActions_1 = require("./HelperActions");
 const SelectAndroidBuildCredentials_1 = require("./SelectAndroidBuildCredentials");
 const SelectBuildProfileFromEasJson_1 = require("./SelectBuildProfileFromEasJson");
 class ManageAndroid {
-    constructor(callingAction) {
+    constructor(callingAction, projectDir) {
         this.callingAction = callingAction;
+        this.projectDir = projectDir;
     }
-    async runAsync(ctx, currentActions = AndroidActions_1.highLevelActions) {
+    async runAsync(currentActions = AndroidActions_1.highLevelActions) {
+        const hasProjectContext = !!context_1.CredentialsContext.getExpoConfigInProject(this.projectDir);
+        const buildProfile = hasProjectContext
+            ? await new SelectBuildProfileFromEasJson_1.SelectBuildProfileFromEasJson(this.projectDir, eas_build_job_1.Platform.ANDROID).runAsync()
+            : null;
+        const ctx = new context_1.CredentialsContext({
+            projectDir: process.cwd(),
+            user: await (0, actions_1.ensureLoggedInAsync)(),
+            env: buildProfile === null || buildProfile === void 0 ? void 0 : buildProfile.env,
+        });
         const accountName = ctx.hasProjectContext
             ? (0, projectUtils_1.getProjectAccountName)(ctx.exp, ctx.user)
             : (0, actions_1.ensureActorHasUsername)(ctx.user);
@@ -42,7 +53,11 @@ class ManageAndroid {
         if (!account) {
             throw new Error(`You do not have access to account: ${accountName}`);
         }
-        const { gradleContext } = await this.createProjectContextAsync(ctx);
+        let gradleContext;
+        if (ctx.hasProjectContext) {
+            (0, assert_1.default)(buildProfile, 'buildProfile must be defined in a project context');
+            gradleContext = await this.createProjectContextAsync(ctx, buildProfile);
+        }
         while (true) {
             try {
                 if (ctx.hasProjectContext) {
@@ -114,20 +129,13 @@ class ManageAndroid {
             await new HelperActions_1.PressAnyKeyToContinue().runAsync();
         }
     }
-    async createProjectContextAsync(ctx) {
-        if (!ctx.hasProjectContext) {
-            return {};
-        }
+    async createProjectContextAsync(ctx, buildProfile) {
+        (0, assert_1.default)(ctx.hasProjectContext, 'createProjectContextAsync: must have project context.');
         const maybeProjectId = await (0, projectUtils_1.promptToCreateProjectIfNotExistsAsync)(ctx.exp);
         if (!maybeProjectId) {
             throw new Error('Your project must be registered with EAS in order to use the credentials manager.');
         }
-        const buildProfile = await new SelectBuildProfileFromEasJson_1.SelectBuildProfileFromEasJson(ctx.projectDir, eas_build_job_1.Platform.ANDROID).runAsync(ctx);
-        const gradleContext = await (0, gradle_1.resolveGradleBuildContextAsync)(ctx.projectDir, buildProfile);
-        return {
-            gradleContext,
-            buildProfile,
-        };
+        return await (0, gradle_1.resolveGradleBuildContextAsync)(ctx.projectDir, buildProfile);
     }
     async runProjectSpecificActionAsync(ctx, action, gradleContext) {
         (0, assert_1.default)(ctx.hasProjectContext, 'You must be in your project directory in order to perform this action');

package/build/credentials/manager/ManageIos.d.ts

@@ -1,10 +1,10 @@
-import { CredentialsContext } from '../context';
 import { ActionInfo } from './Actions';
 import { Action } from './HelperActions';
 export declare class ManageIos {
     private callingAction;
-    constructor(callingAction: Action);
-    runAsync(ctx: CredentialsContext, currentActions?: ActionInfo[]): Promise<void>;
+    private projectDir;
+    constructor(callingAction: Action, projectDir: string);
+    runAsync(currentActions?: ActionInfo[]): Promise<void>;
     private createProjectContextAsync;
     private runAccountSpecificActionAsync;
     private runProjectSpecificActionAsync;

package/build/credentials/manager/ManageIos.js

@@ -13,6 +13,7 @@ const projectUtils_1 = require("../../project/projectUtils");
 const prompts_1 = require("../../prompts");
 const Account_1 = require("../../user/Account");
 const actions_1 = require("../../user/actions");
+const context_1 = require("../context");
 const AscApiKeyUtils_1 = require("../ios/actions/AscApiKeyUtils");
 const AssignAscApiKey_1 = require("../ios/actions/AssignAscApiKey");
 const AssignPushKey_1 = require("../ios/actions/AssignPushKey");
@@ -41,10 +42,20 @@ const IosActions_1 = require("./IosActions");
 const SelectBuildProfileFromEasJson_1 = require("./SelectBuildProfileFromEasJson");
 const SelectIosDistributionTypeGraphqlFromBuildProfile_1 = require("./SelectIosDistributionTypeGraphqlFromBuildProfile");
 class ManageIos {
-    constructor(callingAction) {
+    constructor(callingAction, projectDir) {
         this.callingAction = callingAction;
+        this.projectDir = projectDir;
     }
-    async runAsync(ctx, currentActions = IosActions_1.highLevelActions) {
+    async runAsync(currentActions = IosActions_1.highLevelActions) {
+        const hasProjectContext = !!context_1.CredentialsContext.getExpoConfigInProject(this.projectDir);
+        const buildProfile = hasProjectContext
+            ? await new SelectBuildProfileFromEasJson_1.SelectBuildProfileFromEasJson(this.projectDir, eas_build_job_1.Platform.IOS).runAsync()
+            : null;
+        const ctx = new context_1.CredentialsContext({
+            projectDir: process.cwd(),
+            user: await (0, actions_1.ensureLoggedInAsync)(),
+            env: buildProfile === null || buildProfile === void 0 ? void 0 : buildProfile.env,
+        });
         const buildCredentialsActions = (0, IosActions_1.getBuildCredentialsActions)(ctx);
         const pushKeyActions = (0, IosActions_1.getPushKeyActions)(ctx);
         const ascApiKeyActions = (0, IosActions_1.getAscApiKeyActions)(ctx);
@@ -56,7 +67,14 @@ class ManageIos {
         if (!account) {
             throw new Error(`You do not have access to account: ${accountName}`);
         }
-        const { app, targets, buildProfile } = await this.createProjectContextAsync(ctx, account);
+        let app = null;
+        let targets = null;
+        if (ctx.hasProjectContext) {
+            (0, assert_1.default)(buildProfile, 'buildProfile must be defined in project context');
+            const projectContext = await this.createProjectContextAsync(ctx, account, buildProfile);
+            app = projectContext.app;
+            targets = projectContext.targets;
+        }
         while (true) {
             try {
                 if (ctx.hasProjectContext) {
@@ -128,20 +146,13 @@ class ManageIos {
             await new HelperActions_1.PressAnyKeyToContinue().runAsync();
         }
     }
-    async createProjectContextAsync(ctx, account) {
-        if (!ctx.hasProjectContext) {
-            return {
-                app: null,
-                targets: null,
-                buildProfile: null,
-            };
-        }
+    async createProjectContextAsync(ctx, account, buildProfile) {
+        (0, assert_1.default)(ctx.hasProjectContext, 'createProjectContextAsync: must have project context.');
         const maybeProjectId = await (0, projectUtils_1.promptToCreateProjectIfNotExistsAsync)(ctx.exp);
         if (!maybeProjectId) {
             throw new Error('Your project must be registered with EAS in order to use the credentials manager.');
         }
         const app = { account, projectName: ctx.exp.slug };
-        const buildProfile = await new SelectBuildProfileFromEasJson_1.SelectBuildProfileFromEasJson(ctx.projectDir, eas_build_job_1.Platform.IOS).runAsync(ctx);
         const xcodeBuildContext = await (0, scheme_1.resolveXcodeBuildContextAsync)({
             projectDir: ctx.projectDir,
             nonInteractive: ctx.nonInteractive,
@@ -151,7 +162,6 @@ class ManageIos {
         return {
             app,
             targets,
-            buildProfile,
         };
     }
     async runAccountSpecificActionAsync(ctx, account, action) {

package/build/credentials/manager/SelectBuildProfileFromEasJson.d.ts

@@ -1,10 +1,9 @@
 import { Platform } from '@expo/eas-build-job';
 import { BuildProfile } from '@expo/eas-json';
-import { CredentialsContext } from '../context';
 export declare class SelectBuildProfileFromEasJson<T extends Platform> {
     private platform;
     private easJsonReader;
     constructor(projectDir: string, platform: T);
-    runAsync(ctx: CredentialsContext): Promise<BuildProfile<T>>;
-    getProfileNameFromEasConfigAsync(ctx: CredentialsContext): Promise<string>;
+    runAsync(): Promise<BuildProfile<T>>;
+    getProfileNameFromEasConfigAsync(): Promise<string>;
 }