@donotuse/eas-cli 18.5.0-rc.1

package/build/channel/queries.js

@@ -0,0 +1,274 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CHANNELS_LIMIT = void 0;
+exports.selectChannelOnAppAsync = selectChannelOnAppAsync;
+exports.listAndRenderChannelsOnAppAsync = listAndRenderChannelsOnAppAsync;
+exports.listAndRenderBranchesAndUpdatesOnChannelAsync = listAndRenderBranchesAndUpdatesOnChannelAsync;
+exports.createChannelOnAppAsync = createChannelOnAppAsync;
+exports.ensureChannelExistsAsync = ensureChannelExistsAsync;
+exports.doesChannelExistAsync = doesChannelExistAsync;
+exports.createAndLinkChannelAsync = createAndLinkChannelAsync;
+const tslib_1 = require("tslib");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const graphql_1 = require("graphql");
+const graphql_tag_1 = tslib_1.__importDefault(require("graphql-tag"));
+const errors_1 = require("./errors");
+const print_utils_1 = require("./print-utils");
+const queries_1 = require("../branch/queries");
+const utils_1 = require("../branch/utils");
+const client_1 = require("../graphql/client");
+const BranchQuery_1 = require("../graphql/queries/BranchQuery");
+const ChannelQuery_1 = require("../graphql/queries/ChannelQuery");
+const UpdateChannelBasicInfo_1 = require("../graphql/types/UpdateChannelBasicInfo");
+const log_1 = tslib_1.__importStar(require("../log"));
+const projectUtils_1 = require("../project/projectUtils");
+const formatFields_1 = tslib_1.__importDefault(require("../utils/formatFields"));
+const json_1 = require("../utils/json");
+const queries_2 = require("../utils/queries");
+exports.CHANNELS_LIMIT = 25;
+async function selectChannelOnAppAsync(graphqlClient, { projectId, selectionPromptTitle, paginatedQueryOptions, }) {
+    if (paginatedQueryOptions.nonInteractive) {
+        const channels = await queryChannelsOnAppAsync(graphqlClient, {
+            appId: projectId,
+            limit: paginatedQueryOptions.limit ?? exports.CHANNELS_LIMIT,
+            offset: paginatedQueryOptions.offset,
+        });
+        if (channels.length === 0) {
+            throw new Error(`No channels found for project "${projectId}".`);
+        }
+        const channelList = channels.map(c => c.name).join('\n  ');
+        throw new Error(`Unable to select a channel in non-interactive mode. Use the --channel flag to specify the channel. Available channels:\n  ${channelList}`);
+    }
+    const updateChannel = await (0, queries_2.paginatedQueryWithSelectPromptAsync)({
+        limit: paginatedQueryOptions.limit ?? exports.CHANNELS_LIMIT,
+        offset: paginatedQueryOptions.offset,
+        queryToPerform: (limit, offset) => queryChannelsOnAppAsync(graphqlClient, { appId: projectId, limit, offset }),
+        promptOptions: {
+            title: selectionPromptTitle,
+            makePartialChoiceObject: updateChannel => ({ title: updateChannel.name }),
+            getIdentifierForQueryItem: updateChannel => updateChannel.id,
+        },
+    });
+    if (!updateChannel) {
+        throw new Error(`Could not find any channels for app "${projectId}"`);
+    }
+    return updateChannel;
+}
+async function listAndRenderChannelsOnAppAsync(graphqlClient, { projectId, paginatedQueryOptions, }) {
+    if (paginatedQueryOptions.nonInteractive) {
+        const channels = await queryChannelsOnAppAsync(graphqlClient, {
+            appId: projectId,
+            limit: paginatedQueryOptions.limit ?? exports.CHANNELS_LIMIT,
+            offset: paginatedQueryOptions.offset,
+        });
+        renderPageOfChannels(channels, paginatedQueryOptions);
+    }
+    else {
+        await (0, queries_2.paginatedQueryWithConfirmPromptAsync)({
+            limit: paginatedQueryOptions.limit ?? exports.CHANNELS_LIMIT,
+            offset: paginatedQueryOptions.offset,
+            queryToPerform: (limit, offset) => queryChannelsOnAppAsync(graphqlClient, { limit, offset, appId: projectId }),
+            promptOptions: {
+                title: 'Load more channels?',
+                renderListItems: channels => {
+                    renderPageOfChannels(channels, paginatedQueryOptions);
+                },
+            },
+        });
+    }
+}
+async function listAndRenderBranchesAndUpdatesOnChannelAsync(graphqlClient, { projectId: appId, channelName, paginatedQueryOptions, }) {
+    const channel = await ChannelQuery_1.ChannelQuery.viewUpdateChannelAsync(graphqlClient, { appId, channelName });
+    renderChannelHeaderContent({
+        channelName: channel.name,
+        channelId: channel.id,
+        isPaused: channel.isPaused,
+    });
+    if (paginatedQueryOptions.nonInteractive) {
+        const branches = await queryBranchesAndUpdateGroupsOnChannelAsync(graphqlClient, {
+            appId,
+            channelName,
+            offset: paginatedQueryOptions.offset,
+            limit: paginatedQueryOptions.limit ?? exports.CHANNELS_LIMIT,
+        });
+        renderPageOfBranchesOnChannel(channel, branches, paginatedQueryOptions);
+    }
+    else {
+        await (0, queries_2.paginatedQueryWithConfirmPromptAsync)({
+            limit: paginatedQueryOptions.limit ?? exports.CHANNELS_LIMIT,
+            offset: paginatedQueryOptions.offset,
+            queryToPerform: (limit, offset) => queryBranchesAndUpdateGroupsOnChannelAsync(graphqlClient, {
+                channelName,
+                appId,
+                offset,
+                limit,
+            }),
+            promptOptions: {
+                title: 'Load more channels?',
+                renderListItems: branches => {
+                    renderPageOfBranchesOnChannel(channel, branches, paginatedQueryOptions);
+                },
+            },
+        });
+    }
+}
+async function queryChannelsOnAppAsync(graphqlClient, { appId, offset, limit }) {
+    return await ChannelQuery_1.ChannelQuery.viewUpdateChannelsOnAppAsync(graphqlClient, {
+        appId,
+        offset,
+        limit,
+    });
+}
+async function queryBranchesAndUpdateGroupsOnChannelAsync(graphqlClient, args) {
+    return await BranchQuery_1.BranchQuery.listBranchesOnChannelAsync(graphqlClient, args);
+}
+function renderPageOfChannels(currentPage, { json }) {
+    if (json) {
+        (0, json_1.printJsonOnlyOutput)({ currentPage });
+    }
+    else {
+        for (const channel of currentPage) {
+            renderChannelHeaderContent({
+                channelName: channel.name,
+                channelId: channel.id,
+                isPaused: channel.isPaused,
+            });
+            log_1.default.addNewLineIfNone();
+            (0, print_utils_1.logChannelDetails)(channel);
+            if (currentPage.indexOf(channel) < currentPage.length - 1) {
+                log_1.default.log(`\n${chalk_1.default.dim('———')}\n`);
+            }
+        }
+    }
+}
+function renderPageOfBranchesOnChannel(channel, currentPage, { json }) {
+    const channelWithNewBranches = { ...channel, updateBranches: currentPage };
+    if (json) {
+        (0, json_1.printJsonOnlyOutput)({ currentPage: channelWithNewBranches });
+    }
+    else {
+        // The channel details contain both the branch and latest update group
+        log_1.default.addNewLineIfNone();
+        (0, print_utils_1.logChannelDetails)(channelWithNewBranches);
+    }
+}
+function renderChannelHeaderContent({ channelName, channelId, isPaused, }) {
+    log_1.default.addNewLineIfNone();
+    log_1.default.log(chalk_1.default.bold('Channel:'));
+    log_1.default.log((0, formatFields_1.default)([
+        { label: 'Name', value: channelName },
+        { label: 'ID', value: channelId },
+        { label: 'Status', value: isPaused ? 'Paused' : 'Active' },
+    ]));
+    log_1.default.addNewLineIfNone();
+    log_1.default.log((0, chalk_1.default) `{bold Branches pointed at this channel and their most recent update group:}`);
+}
+async function createChannelOnAppAsync(graphqlClient, { appId, branchId, channelName, }) {
+    // Point the new channel at a branch with its same name.
+    const branchMapping = JSON.stringify({
+        data: [{ branchId, branchMappingLogic: 'true' }],
+        version: 0,
+    });
+    return await (0, client_1.withErrorHandlingAsync)(graphqlClient
+        .mutation((0, graphql_tag_1.default) `
+          mutation CreateUpdateChannelOnApp($appId: ID!, $name: String!, $branchMapping: String!) {
+            updateChannel {
+              createUpdateChannelForApp(appId: $appId, name: $name, branchMapping: $branchMapping) {
+                id
+                ...UpdateChannelBasicInfoFragment
+              }
+            }
+          }
+          ${(0, graphql_1.print)(UpdateChannelBasicInfo_1.UpdateChannelBasicInfoFragmentNode)}
+        `, {
+        appId,
+        name: channelName,
+        branchMapping,
+    })
+        .toPromise());
+}
+async function ensureChannelExistsAsync(graphqlClient, { appId, branchId, channelName }) {
+    try {
+        await createChannelOnAppAsync(graphqlClient, {
+            appId,
+            channelName,
+            branchId,
+        });
+    }
+    catch (e) {
+        const isIgnorableError = e.graphQLErrors?.length === 1 &&
+            e.graphQLErrors[0].extensions.errorCode === 'CHANNEL_ALREADY_EXISTS';
+        if (!isIgnorableError) {
+            throw e;
+        }
+    }
+}
+async function doesChannelExistAsync(graphqlClient, { appId, channelName }) {
+    try {
+        await ChannelQuery_1.ChannelQuery.viewUpdateChannelBasicInfoAsync(graphqlClient, {
+            appId,
+            channelName,
+        });
+    }
+    catch (err) {
+        if (err instanceof errors_1.ChannelNotFoundError) {
+            return false;
+        }
+        throw err;
+    }
+    return true;
+}
+/**
+ * Creates a channel and links it to a branch with the same name.
+ *
+ * @param appId the app ID, also known as the project ID
+ * @param channelName the name of the channel to create
+ * @param shouldPrintJson print only the JSON output
+ */
+async function createAndLinkChannelAsync(graphqlClient, { appId, channelName, shouldPrintJson, }) {
+    let branchId;
+    let hasCreatedBranch = false;
+    try {
+        const branch = await BranchQuery_1.BranchQuery.getBranchByNameAsync(graphqlClient, {
+            appId,
+            name: channelName,
+        });
+        branchId = branch.id;
+    }
+    catch (error) {
+        if (error instanceof utils_1.BranchNotFoundError) {
+            const newBranch = await (0, queries_1.createUpdateBranchOnAppAsync)(graphqlClient, {
+                appId,
+                name: channelName,
+            });
+            branchId = newBranch.id;
+            hasCreatedBranch = true;
+        }
+        else {
+            throw error;
+        }
+    }
+    const { updateChannel: { createUpdateChannelForApp: newChannel }, } = await createChannelOnAppAsync(graphqlClient, {
+        appId,
+        channelName,
+        branchId,
+    });
+    if (!newChannel) {
+        throw new Error(`Could not create channel with name ${channelName} on project with id ${appId}`);
+    }
+    if (shouldPrintJson) {
+        (0, json_1.printJsonOnlyOutput)(newChannel);
+    }
+    else {
+        const projectDisplayName = await (0, projectUtils_1.getDisplayNameForProjectIdAsync)(graphqlClient, appId);
+        const learnMoreLink = (0, log_1.learnMore)('https://docs.expo.dev/eas-update/eas-cli/');
+        log_1.default.addNewLineIfNone();
+        if (hasCreatedBranch) {
+            log_1.default.withTick(`Created update channel ${chalk_1.default.bold(`"${newChannel.name}"`)} and branch ${chalk_1.default.bold(`"${newChannel.name}"`)} on ${chalk_1.default.bold(projectDisplayName)} project. ${learnMoreLink}`);
+        }
+        else {
+            log_1.default.withTick(`Created update channel ${chalk_1.default.bold(`"${newChannel.name}"`)} on ${chalk_1.default.bold(projectDisplayName)} project and connected it with existing ${chalk_1.default.bold(`"${newChannel.name}"`)} branch. ${learnMoreLink}`);
+        }
+    }
+    return newChannel;
+}

package/build/channel/utils.d.ts

@@ -0,0 +1,13 @@
+export type ChannelBasicInfo = {
+    id: string;
+    name: string;
+    branchMapping: string;
+};
+export type BranchBasicInfo = {
+    id: string;
+    name: string;
+};
+export type UpdateChannelInfoWithBranches<Branch extends BranchBasicInfo> = ChannelBasicInfo & {
+    updateBranches: Branch[];
+};
+export declare function getUpdateBranch<Branch extends BranchBasicInfo>(channel: UpdateChannelInfoWithBranches<Branch>, branchId: string): Branch;

package/build/channel/utils.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getUpdateBranch = getUpdateBranch;
+function getUpdateBranchNullable(channel, branchId) {
+    const updateBranches = channel.updateBranches;
+    const updateBranch = updateBranches.find(branch => branch.id === branchId);
+    return updateBranch ?? null;
+}
+function getUpdateBranch(channel, branchId) {
+    const updateBranch = getUpdateBranchNullable(channel, branchId);
+    if (!updateBranch) {
+        throw new Error(`Could not find branch with id "${branchId}" in branch-mapping of channel "${channel.name}"`);
+    }
+    return updateBranch;
+}

package/build/commandUtils/EasCommand.d.ts

@@ -0,0 +1,151 @@
+import { Command } from '@oclif/core';
+import AnalyticsContextField from './context/AnalyticsContextField';
+import ContextField from './context/ContextField';
+import DynamicLoggedInContextField from './context/DynamicLoggedInContextField';
+import { DynamicPrivateProjectConfigContextField, DynamicPublicProjectConfigContextField } from './context/DynamicProjectConfigContextField';
+import LoggedInContextField from './context/LoggedInContextField';
+import MaybeLoggedInContextField from './context/MaybeLoggedInContextField';
+import { OptionalPrivateProjectConfigContextField } from './context/OptionalPrivateProjectConfigContextField';
+import { PrivateProjectConfigContextField } from './context/PrivateProjectConfigContextField';
+import ProjectDirContextField from './context/ProjectDirContextField';
+import { ProjectIdContextField } from './context/ProjectIdContextField';
+import { ServerSideEnvironmentVariablesContextField } from './context/ServerSideEnvironmentVariablesContextField';
+import SessionManagementContextField from './context/SessionManagementContextField';
+import VcsClientContextField from './context/VcsClientContextField';
+import { Client } from '../vcs/vcs';
+export type ContextInput<T extends {
+    [name: string]: any;
+} = object> = {
+    [P in keyof T]: ContextField<T[P]>;
+};
+export type ContextOutput<T extends {
+    [name: string]: any;
+} = object> = {
+    [P in keyof T]: T[P];
+};
+type GetContextType<Type> = {
+    [Property in keyof Type]: any;
+};
+interface BaseGetContextAsyncArgs {
+    nonInteractive: boolean;
+    vcsClientOverride?: Client;
+}
+interface GetContextAsyncArgsWithRequiredServerSideEnvironmentArgument extends BaseGetContextAsyncArgs {
+    withServerSideEnvironment: string | null;
+}
+interface GetContextAsyncArgsWithoutServerSideEnvironmentArgument extends BaseGetContextAsyncArgs {
+    withServerSideEnvironment?: never;
+}
+export default abstract class EasCommand extends Command {
+    protected static readonly ContextOptions: {
+        /**
+         * Require this command to be run when logged-in. Returns the logged-in actor and a logged-in
+         * graphql client in the context.
+         */
+        LoggedIn: {
+            loggedIn: LoggedInContextField;
+        };
+        /**
+         * Do not require this command to be run when logged-in, but if it is get the logged-in actor and a
+         * maybe-logged-in graphql client.
+         */
+        MaybeLoggedIn: {
+            maybeLoggedIn: MaybeLoggedInContextField;
+        };
+        /**
+         * Specify this context if the logged-in requirement is only necessary in a particular execution of the command.
+         */
+        DynamicLoggedIn: {
+            getDynamicLoggedInAsync: DynamicLoggedInContextField;
+        };
+        /**
+         * Specify this context requirement if the command needs to mutate the user session.
+         * @deprecated Should not be used outside of session management commands, which currently only includes `login` and `logout`.
+         */
+        SessionManagment: {
+            sessionManager: SessionManagementContextField;
+        };
+        /**
+         * Require the project to be identified and registered on server if this command is being
+         * run within a project directory, null otherwise.
+         */
+        OptionalProjectConfig: {
+            optionalPrivateProjectConfig: OptionalPrivateProjectConfigContextField;
+        };
+        /**
+         * Require this command to be run in a project directory. Return the project directory in the context.
+         */
+        ProjectDir: {
+            projectDir: ProjectDirContextField;
+        };
+        /**
+         * Provides functions to load the project config when dynamic config options are needed (custom Env for example).
+         */
+        DynamicProjectConfig: {
+            getDynamicPublicProjectConfigAsync: DynamicPublicProjectConfigContextField;
+            getDynamicPrivateProjectConfigAsync: DynamicPrivateProjectConfigContextField;
+        };
+        /**
+         * Require the project to be identified and registered on server. Returns the project config in the context.
+         * This also requires the user to be logged in (getProjectIdAsync requires logged in), so also expose that context.
+         * Exposing the loggedIn context here helps us guarantee user identification for logging purposes.
+         */
+        ProjectConfig: {
+            loggedIn: LoggedInContextField;
+            privateProjectConfig: PrivateProjectConfigContextField;
+        };
+        /**
+         * Analytics manager. Returns the analytics manager in the context for use by the command.
+         */
+        Analytics: {
+            analytics: AnalyticsContextField;
+        };
+        Vcs: {
+            vcsClient: VcsClientContextField;
+        };
+        ServerSideEnvironmentVariables: {
+            getServerSideEnvironmentVariablesAsync: ServerSideEnvironmentVariablesContextField;
+        };
+        /**
+         * Require the project to be identified and registered on server. Returns the project ID evaluated from the app config.
+         */
+        ProjectId: {
+            projectId: ProjectIdContextField;
+        };
+    };
+    /**
+     * Context allows for subclasses (commands) to declare their prerequisites in a type-safe manner.
+     * These declarative definitions each output a context property that is the result of the prerequisite being
+     * satisfied. These allow a unified common interface to be shared amongst commands in order to provide a more
+     * consistent CLI experience.
+     *
+     * For example, let's say a command needs the EAS project ID to make a GraphQL mutation. It should declare that
+     * it requires the `ProjectConfig` context, and then call `getContextAsync` to get the project ID.
+     */
+    static contextDefinition: ContextInput;
+    /**
+     * The user session manager. Responsible for coordinating all user session related state.
+     * If needed in a subclass, use the SessionManager ContextOption.
+     */
+    private sessionManagerInternal?;
+    /**
+     * The analytics manager. Used for logging analytics.
+     * It is set up here to ensure a consistent setup.
+     */
+    private analyticsInternal?;
+    /**
+     * Execute the context in the contextDefinition to satisfy command prerequisites.
+     */
+    protected getContextAsync<C extends {
+        [name: string]: any;
+    } = object>(commandClass: {
+        contextDefinition: ContextInput<C>;
+    }, { nonInteractive, vcsClientOverride, withServerSideEnvironment, }: C extends GetContextType<typeof EasCommand.ContextOptions.ProjectConfig> | GetContextType<typeof EasCommand.ContextOptions.DynamicProjectConfig> | GetContextType<typeof EasCommand.ContextOptions.OptionalProjectConfig> | GetContextType<typeof EasCommand.ContextOptions.ServerSideEnvironmentVariables> ? GetContextAsyncArgsWithRequiredServerSideEnvironmentArgument : GetContextAsyncArgsWithoutServerSideEnvironmentArgument): Promise<ContextOutput<C>>;
+    private get sessionManager();
+    private get analytics();
+    protected abstract runAsync(): Promise<any>;
+    run(): Promise<any>;
+    finally(err: Error): Promise<any>;
+    protected catch(err: Error): Promise<any>;
+}
+export {};

package/build/commandUtils/EasCommand.js

@@ -0,0 +1,214 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const core_1 = require("@oclif/core");
+const core_2 = require("@urql/core");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const nullthrows_1 = tslib_1.__importDefault(require("nullthrows"));
+const AnalyticsContextField_1 = tslib_1.__importDefault(require("./context/AnalyticsContextField"));
+const DynamicLoggedInContextField_1 = tslib_1.__importDefault(require("./context/DynamicLoggedInContextField"));
+const DynamicProjectConfigContextField_1 = require("./context/DynamicProjectConfigContextField");
+const LoggedInContextField_1 = tslib_1.__importDefault(require("./context/LoggedInContextField"));
+const MaybeLoggedInContextField_1 = tslib_1.__importDefault(require("./context/MaybeLoggedInContextField"));
+const OptionalPrivateProjectConfigContextField_1 = require("./context/OptionalPrivateProjectConfigContextField");
+const PrivateProjectConfigContextField_1 = require("./context/PrivateProjectConfigContextField");
+const ProjectDirContextField_1 = tslib_1.__importDefault(require("./context/ProjectDirContextField"));
+const ProjectIdContextField_1 = require("./context/ProjectIdContextField");
+const ServerSideEnvironmentVariablesContextField_1 = require("./context/ServerSideEnvironmentVariablesContextField");
+const SessionManagementContextField_1 = tslib_1.__importDefault(require("./context/SessionManagementContextField"));
+const VcsClientContextField_1 = tslib_1.__importDefault(require("./context/VcsClientContextField"));
+const errors_1 = require("./errors");
+const AnalyticsManager_1 = require("../analytics/AnalyticsManager");
+const log_1 = tslib_1.__importStar(require("../log"));
+const SessionManager_1 = tslib_1.__importDefault(require("../user/SessionManager"));
+const BASE_GRAPHQL_ERROR_MESSAGE = 'GraphQL request failed.';
+class EasCommand extends core_1.Command {
+    static ContextOptions = {
+        /**
+         * Require this command to be run when logged-in. Returns the logged-in actor and a logged-in
+         * graphql client in the context.
+         */
+        LoggedIn: {
+            loggedIn: new LoggedInContextField_1.default(),
+        },
+        /**
+         * Do not require this command to be run when logged-in, but if it is get the logged-in actor and a
+         * maybe-logged-in graphql client.
+         */
+        MaybeLoggedIn: {
+            maybeLoggedIn: new MaybeLoggedInContextField_1.default(),
+        },
+        /**
+         * Specify this context if the logged-in requirement is only necessary in a particular execution of the command.
+         */
+        DynamicLoggedIn: {
+            // eslint-disable-next-line async-protect/async-suffix
+            getDynamicLoggedInAsync: new DynamicLoggedInContextField_1.default(),
+        },
+        /**
+         * Specify this context requirement if the command needs to mutate the user session.
+         * @deprecated Should not be used outside of session management commands, which currently only includes `login` and `logout`.
+         */
+        SessionManagment: {
+            sessionManager: new SessionManagementContextField_1.default(),
+        },
+        /**
+         * Require the project to be identified and registered on server if this command is being
+         * run within a project directory, null otherwise.
+         */
+        OptionalProjectConfig: {
+            optionalPrivateProjectConfig: new OptionalPrivateProjectConfigContextField_1.OptionalPrivateProjectConfigContextField(),
+        },
+        /**
+         * Require this command to be run in a project directory. Return the project directory in the context.
+         */
+        ProjectDir: {
+            projectDir: new ProjectDirContextField_1.default(),
+        },
+        /**
+         * Provides functions to load the project config when dynamic config options are needed (custom Env for example).
+         */
+        DynamicProjectConfig: {
+            // eslint-disable-next-line async-protect/async-suffix
+            getDynamicPublicProjectConfigAsync: new DynamicProjectConfigContextField_1.DynamicPublicProjectConfigContextField(),
+            // eslint-disable-next-line async-protect/async-suffix
+            getDynamicPrivateProjectConfigAsync: new DynamicProjectConfigContextField_1.DynamicPrivateProjectConfigContextField(),
+        },
+        /**
+         * Require the project to be identified and registered on server. Returns the project config in the context.
+         * This also requires the user to be logged in (getProjectIdAsync requires logged in), so also expose that context.
+         * Exposing the loggedIn context here helps us guarantee user identification for logging purposes.
+         */
+        ProjectConfig: {
+            loggedIn: new LoggedInContextField_1.default(),
+            privateProjectConfig: new PrivateProjectConfigContextField_1.PrivateProjectConfigContextField(),
+        },
+        /**
+         * Analytics manager. Returns the analytics manager in the context for use by the command.
+         */
+        Analytics: {
+            analytics: new AnalyticsContextField_1.default(),
+        },
+        Vcs: {
+            vcsClient: new VcsClientContextField_1.default(),
+        },
+        ServerSideEnvironmentVariables: {
+            // eslint-disable-next-line async-protect/async-suffix
+            getServerSideEnvironmentVariablesAsync: new ServerSideEnvironmentVariablesContextField_1.ServerSideEnvironmentVariablesContextField(),
+        },
+        /**
+         * Require the project to be identified and registered on server. Returns the project ID evaluated from the app config.
+         */
+        ProjectId: {
+            projectId: new ProjectIdContextField_1.ProjectIdContextField(),
+        },
+    };
+    /**
+     * Context allows for subclasses (commands) to declare their prerequisites in a type-safe manner.
+     * These declarative definitions each output a context property that is the result of the prerequisite being
+     * satisfied. These allow a unified common interface to be shared amongst commands in order to provide a more
+     * consistent CLI experience.
+     *
+     * For example, let's say a command needs the EAS project ID to make a GraphQL mutation. It should declare that
+     * it requires the `ProjectConfig` context, and then call `getContextAsync` to get the project ID.
+     */
+    static contextDefinition = {};
+    /**
+     * The user session manager. Responsible for coordinating all user session related state.
+     * If needed in a subclass, use the SessionManager ContextOption.
+     */
+    sessionManagerInternal;
+    /**
+     * The analytics manager. Used for logging analytics.
+     * It is set up here to ensure a consistent setup.
+     */
+    analyticsInternal;
+    /**
+     * Execute the context in the contextDefinition to satisfy command prerequisites.
+     */
+    async getContextAsync(commandClass, { nonInteractive, vcsClientOverride, 
+    // if specified and not null, the env vars from the selected environment will be fetched from the server
+    // to resolve dynamic config (if dynamic config context is used) and enable getServerSideEnvironmentVariablesAsync function (if server side environment variables context is used)
+    withServerSideEnvironment, }) {
+        const contextDefinition = commandClass.contextDefinition;
+        // do these serially so that they don't do things like ask for login twice in parallel
+        const contextValuePairs = [];
+        for (const [contextKey, contextField] of Object.entries(contextDefinition)) {
+            contextValuePairs.push([
+                contextKey,
+                await contextField.getValueAsync({
+                    nonInteractive,
+                    sessionManager: this.sessionManager,
+                    analytics: this.analytics,
+                    vcsClientOverride,
+                    withServerSideEnvironment,
+                }),
+            ]);
+        }
+        return Object.fromEntries(contextValuePairs);
+    }
+    get sessionManager() {
+        return (0, nullthrows_1.default)(this.sessionManagerInternal);
+    }
+    get analytics() {
+        return (0, nullthrows_1.default)(this.analyticsInternal);
+    }
+    // eslint-disable-next-line async-protect/async-suffix
+    async run() {
+        this.analyticsInternal = await (0, AnalyticsManager_1.createAnalyticsAsync)();
+        this.sessionManagerInternal = new SessionManager_1.default(this.analytics);
+        // this is needed for logEvent call below as it identifies the user in the analytics system
+        // if possible
+        await this.sessionManager.getUserAsync();
+        this.analytics.logEvent(AnalyticsManager_1.CommandEvent.ACTION, {
+            // id is assigned by oclif in constructor based on the filepath:
+            // commands/submit === submit, commands/build/list === build:list
+            action: `eas ${this.id}`,
+        });
+        return await this.runAsync();
+    }
+    // eslint-disable-next-line async-protect/async-suffix
+    async finally(err) {
+        await this.analytics.flushAsync();
+        return await super.finally(err);
+    }
+    catch(err) {
+        let baseMessage = `${this.id} command failed.`;
+        if (err instanceof errors_1.EasCommandError) {
+            log_1.default.error(err.message);
+        }
+        else if (err instanceof core_2.CombinedError && err?.graphQLErrors) {
+            const cleanGQLErrorsMessage = err?.graphQLErrors
+                .map((graphQLError) => {
+                const messageLine = graphQLError.message.replace('[GraphQL] ', '');
+                const requestIdLine = graphQLError.extensions?.requestId
+                    ? `\nRequest ID: ${err.graphQLErrors[0].extensions.requestId}`
+                    : '';
+                const defaultMsg = `${messageLine}${requestIdLine}`;
+                if (graphQLError.extensions?.errorCode === 'UNAUTHORIZED_ERROR') {
+                    if (defaultMsg.includes('ScopedAccountActorViewerContext') && process.env.EAS_BUILD) {
+                        // We're in EAS, authenticated with a scoped account actor access token.
+                        // We may have not added the scoped actor privacy rule to the right place yet.
+                        return `${chalk_1.default.bold(`You don't have the required permissions to perform this operation.`)}\n\nWe are in the process of migrating EAS to a more granular permissioning system. If you believe what you're doing is a legitimate operation you should be able to perform, report this to us at ${(0, log_1.link)('https://expo.dev/contact')}\n\nOriginal error message: ${defaultMsg}`;
+                    }
+                    return `${chalk_1.default.bold(`You don't have the required permissions to perform this operation.`)}\n\nThis can sometimes happen if you are logged in as incorrect user.\nRun ${chalk_1.default.bold('eas whoami')} to check the username you are logged in as.\nRun ${chalk_1.default.bold('eas login')} to change the account.\n\nOriginal error message: ${defaultMsg}`;
+                }
+                return defaultMsg;
+            })
+                .join('\n');
+            const cleanMessage = err.networkError
+                ? `${cleanGQLErrorsMessage}\n${err.networkError.message}`
+                : cleanGQLErrorsMessage;
+            log_1.default.error(cleanMessage);
+            baseMessage = BASE_GRAPHQL_ERROR_MESSAGE;
+        }
+        else {
+            log_1.default.error(err.message);
+        }
+        log_1.default.debug(err);
+        const sanitizedError = new Error(baseMessage);
+        sanitizedError.stack = err.stack;
+        throw sanitizedError;
+    }
+}
+exports.default = EasCommand;