[14/n][eas-cli] Simplify credentials manager and device create for within-project-only running

packages/eas-cli/src/build/android/build.ts

@@ -57,7 +57,7 @@ This means that it will most likely produce an AAB and you will not be able to i
   const gradleContext = await resolveGradleBuildContextAsync(ctx.projectDir, buildProfile);
 
   if (ctx.workflow === Workflow.MANAGED) {
-    await ensureApplicationIdIsDefinedForManagedProjectAsync(ctx.projectDir, ctx.exp);
+    await ensureApplicationIdIsDefinedForManagedProjectAsync(ctx.projectDir, ctx.exp, ctx.user);
   }
 
   const applicationId = await getApplicationIdAsync(ctx.projectDir, ctx.exp, gradleContext);
@@ -91,7 +91,7 @@ export async function prepareAndroidBuildAsync(
           ctx.easJsonCliConfig?.appVersionSource === AppVersionSource.REMOTE
             ? false
             : ctx.buildProfile.autoIncrement,
-        nonInteractive: ctx.nonInteractive,
+        projectId: ctx.projectId,
       });
     },
     prepareJobAsync: async (

packages/eas-cli/src/build/android/prepareJob.ts

@@ -5,7 +5,6 @@ import slash from 'slash';
 
 import { AndroidCredentials } from '../../credentials/android/AndroidCredentialsProvider';
 import { getUsername } from '../../project/projectUtils';
-import { ensureLoggedInAsync } from '../../user/actions';
 import { getVcsClient } from '../../vcs';
 import { BuildContext } from '../context';
 
@@ -24,10 +23,7 @@ export async function prepareJobAsync(
   ctx: BuildContext<Platform.ANDROID>,
   jobData: JobData
 ): Promise<Job> {
-  const username = getUsername(
+  const username = getUsername(ctx.exp, ctx.user);
-    ctx.exp,
-    await ensureLoggedInAsync({ nonInteractive: ctx.nonInteractive })
-  );
   const buildProfile: BuildProfile<Platform.ANDROID> = ctx.buildProfile;
   const projectRootDirectory =
     slash(path.relative(await getVcsClient().getRootPathAsync(), ctx.projectDir)) || '.';

packages/eas-cli/src/build/android/syncProjectConfiguration.ts

@@ -16,12 +16,12 @@ export async function syncProjectConfigurationAsync({
   projectDir,
   exp,
   localAutoIncrement,
-  nonInteractive,
+  projectId,
 }: {
   projectDir: string;
   exp: ExpoConfig;
   localAutoIncrement?: AndroidVersionAutoIncrement;
-  nonInteractive: boolean;
+  projectId: string;
 }): Promise<void> {
   const workflow = await resolveWorkflowAsync(projectDir, Platform.ANDROID);
   const versionBumpStrategy = resolveVersionBumpStrategy(localAutoIncrement ?? false);
@@ -29,7 +29,7 @@ export async function syncProjectConfigurationAsync({
   if (workflow === Workflow.GENERIC) {
     await cleanUpOldEasBuildGradleScriptAsync(projectDir);
     if (isExpoUpdatesInstalled(projectDir)) {
-      await syncUpdatesConfigurationAsync(projectDir, exp, { nonInteractive });
+      await syncUpdatesConfigurationAsync(projectDir, exp, projectId);
     }
     await bumpVersionAsync({ projectDir, exp, bumpStrategy: versionBumpStrategy });
   } else {

packages/eas-cli/src/build/createContext.ts

@@ -10,9 +10,9 @@ import { Analytics, BuildEvent } from '../analytics/events';
 import { CredentialsContext } from '../credentials/context';
 import { BuildResourceClass } from '../graphql/generated';
 import { getExpoConfig } from '../project/expoConfig';
-import { getOwnerAccountForProjectIdAsync, getProjectIdAsync } from '../project/projectUtils';
+import { getOwnerAccountForProjectIdAsync } from '../project/projectUtils';
 import { resolveWorkflowAsync } from '../project/workflow';
-import { ensureLoggedInAsync } from '../user/actions';
+import { Actor } from '../user/User';
 import { createAndroidContextAsync } from './android/build';
 import { BuildContext, CommonContext } from './context';
 import { createIosContextAsync } from './ios/build';
@@ -30,6 +30,8 @@ export async function createBuildContextAsync<T extends Platform>({
   projectDir,
   resourceClass,
   message,
+  actor,
+  projectId,
 }: {
   buildProfileName: string;
   buildProfile: BuildProfile<T>;
@@ -42,25 +44,22 @@ export async function createBuildContextAsync<T extends Platform>({
   projectDir: string;
   resourceClass: BuildResourceClass;
   message?: string;
+  actor: Actor;
+  projectId: string;
 }): Promise<BuildContext<T>> {
   const exp = getExpoConfig(projectDir, { env: buildProfile.env });
 
-  const user = await ensureLoggedInAsync({ nonInteractive });
   const projectName = exp.slug;
-  const projectId = await getProjectIdAsync(exp, {
-    env: buildProfile.env,
-    nonInteractive,
-  });
   const account = await getOwnerAccountForProjectIdAsync(projectId);
   const workflow = await resolveWorkflowAsync(projectDir, platform);
   const accountId = account.id;
   const runFromCI = getenv.boolish('CI', false);
 
   const credentialsCtx = new CredentialsContext({
-    exp,
+    projectInfo: { exp, projectId },
     nonInteractive,
     projectDir,
-    user,
+    user: actor,
     env: buildProfile.env,
     easJsonCliConfig,
   });
@@ -99,7 +98,7 @@ export async function createBuildContextAsync<T extends Platform>({
     projectId,
     projectName,
     trackingCtx,
-    user,
+    user: actor,
     workflow,
     message,
     runFromCI,

packages/eas-cli/src/build/ios/build.ts

@@ -23,7 +23,7 @@ export async function createIosContextAsync(
   const { buildProfile } = ctx;
 
   if (ctx.workflow === Workflow.MANAGED) {
-    await ensureBundleIdentifierIsDefinedForManagedProjectAsync(ctx.projectDir, ctx.exp);
+    await ensureBundleIdentifierIsDefinedForManagedProjectAsync(ctx.projectDir, ctx.exp, ctx.user);
   }
 
   checkNodeEnvVariable(ctx);
@@ -80,7 +80,7 @@ export async function prepareIosBuildAsync(
           ctx.easJsonCliConfig?.appVersionSource === AppVersionSource.REMOTE
             ? false
             : ctx.buildProfile.autoIncrement,
-        nonInteractive: ctx.nonInteractive,
+        projectId: ctx.projectId,
       });
     },
     prepareJobAsync: async (

packages/eas-cli/src/build/ios/prepareJob.ts

@@ -4,7 +4,6 @@ import slash from 'slash';
 
 import { IosCredentials, TargetCredentials } from '../../credentials/ios/types';
 import { getUsername } from '../../project/projectUtils';
-import { ensureLoggedInAsync } from '../../user/actions';
 import { getVcsClient } from '../../vcs';
 import { BuildContext } from '../context';
 
@@ -26,10 +25,7 @@ export async function prepareJobAsync(
 ): Promise<Job> {
   const projectRootDirectory =
     slash(path.relative(await getVcsClient().getRootPathAsync(), ctx.projectDir)) || '.';
-  const username = getUsername(
+  const username = getUsername(ctx.exp, ctx.user);
-    ctx.exp,
-    await ensureLoggedInAsync({ nonInteractive: ctx.nonInteractive })
-  );
   const buildCredentials: Ios.Job['secrets']['buildCredentials'] = {};
   if (jobData.credentials) {
     const targetNames = Object.keys(jobData.credentials);

packages/eas-cli/src/build/ios/syncProjectConfiguration.ts

@@ -13,20 +13,20 @@ export async function syncProjectConfigurationAsync({
   exp,
   targets,
   localAutoIncrement,
-  nonInteractive,
+  projectId,
 }: {
   projectDir: string;
   exp: ExpoConfig;
   targets: Target[];
   localAutoIncrement?: IosVersionAutoIncrement;
-  nonInteractive: boolean;
+  projectId: string;
 }): Promise<void> {
   const workflow = await resolveWorkflowAsync(projectDir, Platform.IOS);
   const versionBumpStrategy = resolveVersionBumpStrategy(localAutoIncrement ?? false);
 
   if (workflow === Workflow.GENERIC) {
     if (isExpoUpdatesInstalled(projectDir)) {
-      await syncUpdatesConfigurationAsync(projectDir, exp, { nonInteractive });
+      await syncUpdatesConfigurationAsync(projectDir, exp, projectId);
     }
     await bumpVersionAsync({ projectDir, exp, bumpStrategy: versionBumpStrategy, targets });
   } else {

packages/eas-cli/src/build/metadata.ts

@@ -14,7 +14,6 @@ import {
   readChannelSafelyAsync as readIosChannelSafelyAsync,
   readReleaseChannelSafelyAsync as readIosReleaseChannelSafelyAsync,
 } from '../update/ios/UpdatesModule';
-import { ensureLoggedInAsync } from '../user/actions';
 import { easCliVersion } from '../utils/easCli';
 import { getVcsClient } from '../vcs';
 import { maybeResolveVersionsAsync as maybeResolveAndroidVersionsAsync } from './android/version';
@@ -49,10 +48,7 @@ export async function collectMetadataAsync<T extends Platform>(
       (await vcsClient.getLastCommitMessageAsync()) ?? undefined
     ),
     isGitWorkingTreeDirty: await vcsClient.hasUncommittedChangesAsync(),
-    username: getUsername(
+    username: getUsername(ctx.exp, ctx.user),
-      ctx.exp,
-      await ensureLoggedInAsync({ nonInteractive: ctx.nonInteractive })
-    ),
     message: ctx.message,
     ...(ctx.platform === Platform.IOS && {
       iosEnterpriseProvisioning: resolveIosEnterpriseProvisioning(

packages/eas-cli/src/build/runBuildAndSubmit.ts

@@ -41,6 +41,7 @@ import {
   waitToCompleteAsync as waitForSubmissionsToCompleteAsync,
 } from '../submit/submit';
 import { printSubmissionDetailsUrls } from '../submit/utils/urls';
+import { Actor } from '../user/User';
 import { printJsonOnlyOutput } from '../utils/json';
 import { ProfileData, getProfilesAsync } from '../utils/profiles';
 import { getVcsClient } from '../vcs';
@@ -87,7 +88,12 @@ const platformToGraphQLResourceClassMapping: Record<
   },
 };
 
-export async function runBuildAndSubmitAsync(projectDir: string, flags: BuildFlags): Promise<void> {
+export async function runBuildAndSubmitAsync(
+  projectDir: string,
+  flags: BuildFlags,
+  actor: Actor,
+  projectId: string
+): Promise<void> {
   await getVcsClient().ensureRepoExistsAsync();
   await ensureRepoIsCleanAsync(flags.nonInteractive);
 
@@ -134,6 +140,8 @@ export async function runBuildAndSubmitAsync(projectDir: string, flags: BuildFla
           flags.userInputResourceClass ?? UserInputResourceClass.DEFAULT
         ],
       easJsonCliConfig,
+      actor,
+      projectId,
     });
     if (maybeBuild) {
       startedBuilds.push({ build: maybeBuild, buildProfile });
@@ -227,6 +235,8 @@ async function prepareAndStartBuildAsync({
   buildProfile,
   resourceClass,
   easJsonCliConfig,
+  actor,
+  projectId,
 }: {
   projectDir: string;
   flags: BuildFlags;
@@ -234,6 +244,8 @@ async function prepareAndStartBuildAsync({
   buildProfile: ProfileData<'build'>;
   resourceClass: BuildResourceClass;
   easJsonCliConfig: EasJson['cli'];
+  actor: Actor;
+  projectId: string;
 }): Promise<{ build: BuildFragment | undefined; buildCtx: BuildContext<Platform> }> {
   const buildCtx = await createBuildContextAsync({
     buildProfileName: buildProfile.profileName,
@@ -247,6 +259,8 @@ async function prepareAndStartBuildAsync({
     localBuildOptions: flags.localBuildOptions,
     easJsonCliConfig,
     message: flags.message,
+    actor,
+    projectId,
   });
 
   if (moreBuilds) {
@@ -318,6 +332,7 @@ async function prepareAndStartSubmissionAsync({
     env: buildProfile.env,
     credentialsCtx: buildCtx.credentialsCtx,
     applicationIdentifier: buildCtx.android?.applicationId ?? buildCtx.ios?.bundleIdentifier,
+    actor: buildCtx.user,
   });
 
   if (moreBuilds) {

packages/eas-cli/src/commandUtils/EasCommand.ts

@@ -13,20 +13,113 @@ import {
   logEvent,
 } from '../analytics/rudderstackClient';
 import { learnMore } from '../log';
-import { findProjectRootAsync } from '../project/projectUtils';
+import { getExpoConfig } from '../project/expoConfig';
-import { getUserAsync } from '../user/User';
+import { findProjectRootAsync, getProjectIdAsync } from '../project/projectUtils';
+import { Actor, getUserAsync } from '../user/User';
 import { ensureLoggedInAsync } from '../user/actions';
 import { easCliVersion } from '../utils/easCli';
 import { setVcsClient } from '../vcs';
 import GitClient from '../vcs/clients/git';
 
-export default abstract class EasCommand extends Command {
+export interface CommandConfiguration {
   /**
    * When user data is unavailable locally, determines if the command will
-   * force the user to log in
+   * force the user to log in. By default, all commands require authentication.
    */
-  protected requiresAuthentication = true;
+  allowUnauthenticated?: boolean;
-  protected mustBeRunInsideProject = true;
+
+  /**
+   * Whether a command can be run outside of an Expo project directory.
+   * By default, all commands must be run inside an Expo project directory.
+   */
+  canRunOutsideProject?: boolean;
+}
+
+export interface ContextOptions {
+  nonInteractive: boolean;
+}
+
+export abstract class ContextField<T> {
+  abstract getValueAsync(options: ContextOptions): Promise<T>;
+}
+
+export class ProjectIdContextField extends ContextField<string> {
+  async getValueAsync({ nonInteractive }: ContextOptions): Promise<string> {
+    const projectDir = await findProjectRootAsync();
+    const exp = getExpoConfig(projectDir);
+    return await getProjectIdAsync(exp, { nonInteractive });
+  }
+}
+
+export class OptionalProjectIdContextField extends ContextField<string | undefined> {
+  async getValueAsync({ nonInteractive }: ContextOptions): Promise<string | undefined> {
+    const projectDir = await findProjectRootAsync();
+    if (!projectDir) {
+      return undefined;
+    }
+
+    const exp = getExpoConfig(projectDir);
+    return await getProjectIdAsync(exp, { nonInteractive });
+  }
+}
+
+export class ActorContextField extends ContextField<Actor> {
+  async getValueAsync({ nonInteractive }: ContextOptions): Promise<Actor> {
+    return await ensureLoggedInAsync({ nonInteractive });
+  }
+}
+
+export const EASCommandProjectIdContext = {
+  projectId: new ProjectIdContextField(),
+};
+
+export const EASCommandProjectIdIfProjectDirContext = {
+  projectId: new OptionalProjectIdContextField(),
+};
+
+export const EASCommandLoggedInContext = {
+  actor: new ActorContextField(),
+};
+
+type ContextInput<
+  T extends {
+    [name: string]: any;
+  } = object
+> = {
+  [P in keyof T]: ContextField<T[P]>;
+};
+
+type ContextOutput<
+  T extends {
+    [name: string]: any;
+  } = object
+> = {
+  [P in keyof T]: T[P];
+};
+
+export default abstract class EasCommand extends Command {
+  static contextDefinition: ContextInput = {};
+
+  protected commandConfiguration: CommandConfiguration = {};
+
+  protected async getContextAsync<
+    C extends {
+      [name: string]: any;
+    } = object
+  >(
+    commandClass: { contextDefinition: ContextInput<C> },
+    { nonInteractive }: { nonInteractive: boolean }
+  ): Promise<ContextOutput<C>> {
+    const contextDefinition = commandClass.contextDefinition;
+
+    const contextValuePairs = await Promise.all(
+      Object.keys(contextDefinition).map(async contextKey => {
+        return [contextKey, await contextDefinition[contextKey].getValueAsync({ nonInteractive })];
+      })
+    );
+
+    return Object.fromEntries(contextValuePairs);
+  }
 
   protected abstract runAsync(): Promise<any>;
 
@@ -34,24 +127,26 @@ export default abstract class EasCommand extends Command {
   async run(): Promise<any> {
     await initAnalyticsAsync();
 
-    if (this.mustBeRunInsideProject) {
+    if (!this.commandConfiguration.canRunOutsideProject) {
       const projectDir = await findProjectRootAsync();
       await this.applyCliConfigAsync(projectDir);
       await this.ensureEasCliIsNotInDependenciesAsync(projectDir);
     }
 
-    if (this.requiresAuthentication) {
+    if (!this.commandConfiguration.allowUnauthenticated) {
       const { flags } = await this.parse();
       const nonInteractive = (flags as any)['non-interactive'] ?? false;
       await ensureLoggedInAsync({ nonInteractive });
     } else {
       await getUserAsync();
     }
+
     logEvent(AnalyticsEvent.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 this.runAsync();
   }
 

packages/eas-cli/src/commandUtils/__tests__/EasCommand-test.ts

@@ -2,7 +2,7 @@ import { flushAsync, initAsync, logEvent } from '../../analytics/rudderstackClie
 import { jester as mockJester } from '../../credentials/__tests__/fixtures-constants';
 import { getUserAsync } from '../../user/User';
 import { ensureLoggedInAsync } from '../../user/actions';
-import EasCommand from '../EasCommand';
+import EasCommand, { CommandConfiguration } from '../EasCommand';
 
 jest.mock('../../user/User');
 jest.mock('../../user/actions', () => ({ ensureLoggedInAsync: jest.fn() }));
@@ -43,7 +43,9 @@ beforeEach(() => {
 
 const createTestEasCommand = (authValue: boolean): typeof EasCommand => {
   class TestEasCommand extends EasCommand {
-    override requiresAuthentication = authValue;
+    protected override commandConfiguration: CommandConfiguration = {
+      allowUnauthenticated: !authValue,
+    };
 
     async runAsync(): Promise<void> {}
   }

packages/eas-cli/src/commands/account/login.ts

@@ -1,4 +1,4 @@
-import EasCommand from '../../commandUtils/EasCommand';
+import EasCommand, { CommandConfiguration } from '../../commandUtils/EasCommand';
 import Log from '../../log';
 import { showLoginPromptAsync } from '../../user/actions';
 
@@ -6,8 +6,10 @@ export default class AccountLogin extends EasCommand {
   static override description = 'log in with your Expo account';
   static override aliases = ['login'];
 
-  protected override mustBeRunInsideProject = false;
+  protected override commandConfiguration: CommandConfiguration = {
-  protected override requiresAuthentication = false;
+    allowUnauthenticated: true,
+    canRunOutsideProject: true,
+  };
 
   async runAsync(): Promise<void> {
     await showLoginPromptAsync();

packages/eas-cli/src/commands/account/logout.ts

@@ -1,4 +1,4 @@
-import EasCommand from '../../commandUtils/EasCommand';
+import EasCommand, { CommandConfiguration } from '../../commandUtils/EasCommand';
 import Log from '../../log';
 import { logoutAsync } from '../../user/User';
 
@@ -6,8 +6,10 @@ export default class AccountLogout extends EasCommand {
   static override description = 'log out';
   static override aliases = ['logout'];
 
-  protected override mustBeRunInsideProject = false;
+  protected override commandConfiguration: CommandConfiguration = {
-  protected override requiresAuthentication = false;
+    allowUnauthenticated: true,
+    canRunOutsideProject: true,
+  };
 
   async runAsync(): Promise<void> {
     await logoutAsync();

packages/eas-cli/src/commands/account/view.ts

@@ -1,6 +1,6 @@
 import chalk from 'chalk';
 
-import EasCommand from '../../commandUtils/EasCommand';
+import EasCommand, { CommandConfiguration } from '../../commandUtils/EasCommand';
 import Log from '../../log';
 import { getActorDisplayName, getUserAsync } from '../../user/User';
 
@@ -8,8 +8,10 @@ export default class AccountView extends EasCommand {
   static override description = 'show the username you are logged in as';
   static override aliases = ['whoami'];
 
-  protected override mustBeRunInsideProject = false;
+  protected override commandConfiguration: CommandConfiguration = {
-  protected override requiresAuthentication = false;
+    allowUnauthenticated: true,
+    canRunOutsideProject: true,
+  };
 
   async runAsync(): Promise<void> {
     const user = await getUserAsync();

packages/eas-cli/src/commands/analytics.ts

@@ -1,4 +1,4 @@
-import EasCommand from '../commandUtils/EasCommand';
+import EasCommand, { CommandConfiguration } from '../commandUtils/EasCommand';
 import Log from '../log';
 import UserSettings from '../user/UserSettings';
 
@@ -7,7 +7,9 @@ export default class AnalyticsView extends EasCommand {
 
   static override args = [{ name: 'STATUS', options: ['on', 'off'] }];
 
-  protected override requiresAuthentication = false;
+  protected override commandConfiguration: CommandConfiguration = {
+    allowUnauthenticated: true,
+  };
 
   async runAsync(): Promise<void> {
     const { STATUS: status } = (await this.parse(AnalyticsView)).args;

packages/eas-cli/src/commands/branch/create.ts

@@ -2,7 +2,7 @@ import chalk from 'chalk';
 import gql from 'graphql-tag';
 
 import { getDefaultBranchNameAsync } from '../../branch/utils';
-import EasCommand from '../../commandUtils/EasCommand';
+import EasCommand, { EASCommandProjectIdContext } from '../../commandUtils/EasCommand';
 import { EasNonInteractiveAndJsonFlags } from '../../commandUtils/flags';
 import { graphqlClient, withErrorHandlingAsync } from '../../graphql/client';
 import {
@@ -11,12 +11,7 @@ import {
   UpdateBranch,
 } from '../../graphql/generated';
 import Log from '../../log';
-import { getExpoConfig } from '../../project/expoConfig';
+import { getDisplayNameForProjectIdAsync } from '../../project/projectUtils';
-import {
-  findProjectRootAsync,
-  getDisplayNameForProjectIdAsync,
-  getProjectIdAsync,
-} from '../../project/projectUtils';
 import { promptAsync } from '../../prompts';
 import { enableJsonOutput, printJsonOnlyOutput } from '../../utils/json';
 
@@ -66,18 +61,23 @@ export default class BranchCreate extends EasCommand {
     ...EasNonInteractiveAndJsonFlags,
   };
 
+  static override contextDefinition = {
+    ...EASCommandProjectIdContext,
+  };
+
   async runAsync(): Promise<void> {
     let {
       args: { name },
       flags: { json: jsonFlag, 'non-interactive': nonInteractive },
     } = await this.parse(BranchCreate);
+    const { projectId } = await this.getContextAsync(BranchCreate, {
+      nonInteractive,
+    });
+
     if (jsonFlag) {
       enableJsonOutput();
     }
 
-    const projectDir = await findProjectRootAsync();
-    const exp = getExpoConfig(projectDir);
-    const projectId = await getProjectIdAsync(exp, { nonInteractive });
     const projectDisplayName = await getDisplayNameForProjectIdAsync(projectId);
 
     if (!name) {

packages/eas-cli/src/commands/branch/delete.ts

@@ -2,7 +2,7 @@ import chalk from 'chalk';
 import gql from 'graphql-tag';
 
 import { selectBranchOnAppAsync } from '../../branch/queries';
-import EasCommand from '../../commandUtils/EasCommand';
+import EasCommand, { EASCommandProjectIdContext } from '../../commandUtils/EasCommand';
 import { EasNonInteractiveAndJsonFlags } from '../../commandUtils/flags';
 import { getPaginatedQueryOptions } from '../../commandUtils/pagination';
 import { graphqlClient, withErrorHandlingAsync } from '../../graphql/client';
@@ -14,12 +14,7 @@ import {
   GetBranchInfoQueryVariables,
 } from '../../graphql/generated';
 import Log from '../../log';
-import { getExpoConfig } from '../../project/expoConfig';
+import { getDisplayNameForProjectIdAsync } from '../../project/projectUtils';
-import {
-  findProjectRootAsync,
-  getDisplayNameForProjectIdAsync,
-  getProjectIdAsync,
-} from '../../project/projectUtils';
 import { toggleConfirmAsync } from '../../prompts';
 import { enableJsonOutput, printJsonOnlyOutput } from '../../utils/json';
 
@@ -81,6 +76,10 @@ async function deleteBranchOnAppAsync({
 export default class BranchDelete extends EasCommand {
   static override description = 'delete a branch';
 
+  static override contextDefinition = {
+    ...EASCommandProjectIdContext,
+  };
+
   static override args = [
     {
       name: 'name',
@@ -98,15 +97,14 @@ export default class BranchDelete extends EasCommand {
       args: { name: branchName },
       flags,
     } = await this.parse(BranchDelete);
-    const paginatedQueryOptions = getPaginatedQueryOptions(flags);
     const { json: jsonFlag, 'non-interactive': nonInteractive } = flags;
+    const paginatedQueryOptions = getPaginatedQueryOptions(flags);
+
     if (jsonFlag) {
       enableJsonOutput();
     }
 
-    const projectDir = await findProjectRootAsync();
+    const { projectId } = await this.getContextAsync(BranchDelete, { nonInteractive });
-    const exp = getExpoConfig(projectDir);
-    const projectId = await getProjectIdAsync(exp, { nonInteractive });
     const projectDisplayName = await getDisplayNameForProjectIdAsync(projectId);
 
     if (!branchName) {

packages/eas-cli/src/commands/branch/list.ts

@@ -1,9 +1,7 @@
 import { listAndRenderBranchesOnAppAsync } from '../../branch/queries';
-import EasCommand from '../../commandUtils/EasCommand';
+import EasCommand, { EASCommandProjectIdContext } from '../../commandUtils/EasCommand';
 import { EasNonInteractiveAndJsonFlags } from '../../commandUtils/flags';
 import { EasPaginatedQueryFlags, getPaginatedQueryOptions } from '../../commandUtils/pagination';
-import { getExpoConfig } from '../../project/expoConfig';
-import { findProjectRootAsync, getProjectIdAsync } from '../../project/projectUtils';
 import { enableJsonOutput } from '../../utils/json';
 
 export default class BranchList extends EasCommand {
@@ -14,19 +12,21 @@ export default class BranchList extends EasCommand {
     ...EasNonInteractiveAndJsonFlags,
   };
 
+  static override contextDefinition = {
+    ...EASCommandProjectIdContext,
+  };
+
   async runAsync(): Promise<void> {
     const { flags } = await this.parse(BranchList);
+    const { projectId } = await this.getContextAsync(BranchList, {
+      nonInteractive: flags['non-interactive'],
+    });
     const paginatedQueryOptions = getPaginatedQueryOptions(flags);
 
     if (paginatedQueryOptions.json) {
       enableJsonOutput();
     }
 
-    const projectDir = await findProjectRootAsync();
-    const exp = getExpoConfig(projectDir);
-    const projectId = await getProjectIdAsync(exp, {
-      nonInteractive: flags['non-interactive'],
-    });
     await listAndRenderBranchesOnAppAsync({ projectId, paginatedQueryOptions });
   }
 }

packages/eas-cli/src/commands/branch/rename.ts

@@ -2,7 +2,7 @@ import { Flags } from '@oclif/core';
 import chalk from 'chalk';
 import gql from 'graphql-tag';
 
-import EasCommand from '../../commandUtils/EasCommand';
+import EasCommand, { EASCommandProjectIdContext } from '../../commandUtils/EasCommand';
 import { EasNonInteractiveAndJsonFlags } from '../../commandUtils/flags';
 import { graphqlClient, withErrorHandlingAsync } from '../../graphql/client';
 import {
@@ -12,12 +12,7 @@ import {
   UpdateBranch,
 } from '../../graphql/generated';
 import Log from '../../log';
-import { getExpoConfig } from '../../project/expoConfig';
+import { getDisplayNameForProjectIdAsync } from '../../project/projectUtils';
-import {
-  findProjectRootAsync,
-  getDisplayNameForProjectIdAsync,
-  getProjectIdAsync,
-} from '../../project/projectUtils';
 import { promptAsync } from '../../prompts';
 import { enableJsonOutput, printJsonOnlyOutput } from '../../utils/json';
 
@@ -67,17 +62,21 @@ export default class BranchRename extends EasCommand {
     ...EasNonInteractiveAndJsonFlags,
   };
 
+  static override contextDefinition = {
+    ...EASCommandProjectIdContext,
+  };
+
   async runAsync(): Promise<void> {
     let {
       flags: { json: jsonFlag, from: currentName, to: newName, 'non-interactive': nonInteractive },
     } = await this.parse(BranchRename);
+    const { projectId } = await this.getContextAsync(BranchRename, {
+      nonInteractive,
+    });
     if (jsonFlag) {
       enableJsonOutput();
     }
 
-    const projectDir = await findProjectRootAsync();
-    const exp = getExpoConfig(projectDir);
-    const projectId = await getProjectIdAsync(exp, { nonInteractive });
     const projectDisplayName = await getDisplayNameForProjectIdAsync(projectId);
 
     if (!currentName) {

packages/eas-cli/src/commands/branch/view.ts

@@ -1,13 +1,11 @@
 import { selectBranchOnAppAsync } from '../../branch/queries';
-import EasCommand from '../../commandUtils/EasCommand';
+import EasCommand, { EASCommandProjectIdContext } from '../../commandUtils/EasCommand';
 import { EasNonInteractiveAndJsonFlags } from '../../commandUtils/flags';
 import {
   EasPaginatedQueryFlags,
   getLimitFlagWithCustomValues,
   getPaginatedQueryOptions,
 } from '../../commandUtils/pagination';
-import { getExpoConfig } from '../../project/expoConfig';
-import { findProjectRootAsync, getProjectIdAsync } from '../../project/projectUtils';
 import { listAndRenderUpdateGroupsOnBranchAsync } from '../../update/queries';
 import { enableJsonOutput } from '../../utils/json';
 
@@ -28,22 +26,25 @@ export default class BranchView extends EasCommand {
     limit: getLimitFlagWithCustomValues({ defaultTo: 25, limit: 50 }),
   };
 
+  static override contextDefinition = {
+    ...EASCommandProjectIdContext,
+  };
+
   async runAsync(): Promise<void> {
     let {
       args: { name: branchName },
       flags,
     } = await this.parse(BranchView);
     const { 'non-interactive': nonInteractive } = flags;
+    const { projectId } = await this.getContextAsync(BranchView, {
+      nonInteractive,
+    });
     const paginatedQueryOptions = getPaginatedQueryOptions(flags);
 
     if (paginatedQueryOptions.json) {
       enableJsonOutput();
     }
 
-    const projectDir = await findProjectRootAsync();
-    const exp = getExpoConfig(projectDir);
-    const projectId = await getProjectIdAsync(exp, { nonInteractive });
-
     if (!branchName) {
       if (nonInteractive) {
         throw new Error('Branch name may not be empty.');

packages/eas-cli/src/commands/build/cancel.ts

@@ -1,7 +1,7 @@
 import chalk from 'chalk';
 import gql from 'graphql-tag';
 
-import EasCommand from '../../commandUtils/EasCommand';
+import EasCommand, { EASCommandProjectIdContext } from '../../commandUtils/EasCommand';
 import { EASNonInteractiveFlag } from '../../commandUtils/flags';
 import { graphqlClient, withErrorHandlingAsync } from '../../graphql/client';
 import {
@@ -14,12 +14,7 @@ import { BuildQuery } from '../../graphql/queries/BuildQuery';
 import Log from '../../log';
 import { ora } from '../../ora';
 import { appPlatformEmojis } from '../../platform';
-import { getExpoConfig } from '../../project/expoConfig';
+import { getDisplayNameForProjectIdAsync } from '../../project/projectUtils';
-import {
-  findProjectRootAsync,
-  getDisplayNameForProjectIdAsync,
-  getProjectIdAsync,
-} from '../../project/projectUtils';
 import { confirmAsync, selectAsync } from '../../prompts';
 
 async function cancelBuildAsync(buildId: string): Promise<Pick<Build, 'id' | 'status'>> {
@@ -133,15 +128,19 @@ export default class BuildCancel extends EasCommand {
     ...EASNonInteractiveFlag,
   };
 
+  static override contextDefinition = {
+    ...EASCommandProjectIdContext,
+  };
+
   async runAsync(): Promise<void> {
     const {
       args: { BUILD_ID: buildIdFromArg },
       flags: { 'non-interactive': nonInteractive },
     } = await this.parse(BuildCancel);
+    const { projectId } = await this.getContextAsync(BuildCancel, {
+      nonInteractive,
+    });
 
-    const projectDir = await findProjectRootAsync();
-    const exp = getExpoConfig(projectDir);
-    const projectId = await getProjectIdAsync(exp, { nonInteractive });
     const displayName = await getDisplayNameForProjectIdAsync(projectId);
 
     if (buildIdFromArg) {

packages/eas-cli/src/commands/build/configure.ts

@@ -4,7 +4,7 @@ import chalk from 'chalk';
 
 import { cleanUpOldEasBuildGradleScriptAsync } from '../../build/android/syncProjectConfiguration';
 import { ensureProjectConfiguredAsync } from '../../build/configure';
-import EasCommand from '../../commandUtils/EasCommand';
+import EasCommand, { EASCommandProjectIdContext } from '../../commandUtils/EasCommand';
 import Log, { learnMore } from '../../log';
 import { RequestedPlatform } from '../../platform';
 import { getExpoConfig } from '../../project/expoConfig';
@@ -26,8 +26,15 @@ export default class BuildConfigure extends EasCommand {
     }),
   };
 
+  static override contextDefinition = {
+    ...EASCommandProjectIdContext,
+  };
+
   async runAsync(): Promise<void> {
     const { flags } = await this.parse(BuildConfigure);
+    const { projectId } = await this.getContextAsync(BuildConfigure, {
+      nonInteractive: false,
+    });
 
     Log.log(
       '💡 The following process will configure your iOS and/or Android project to be compatible with EAS Build. These changes only apply to your local project files and you can safely revert them at any time.'
@@ -60,14 +67,14 @@ export default class BuildConfigure extends EasCommand {
       if ([RequestedPlatform.Android, RequestedPlatform.All].includes(platform)) {
         const workflow = await resolveWorkflowAsync(projectDir, Platform.ANDROID);
         if (workflow === Workflow.GENERIC) {
-          await syncAndroidUpdatesConfigurationAsync(projectDir, exp, { nonInteractive: false });
+          await syncAndroidUpdatesConfigurationAsync(projectDir, exp, projectId);
         }
       }
 
       if ([RequestedPlatform.Ios, RequestedPlatform.All].includes(platform)) {
         const workflow = await resolveWorkflowAsync(projectDir, Platform.IOS);
         if (workflow === Workflow.GENERIC) {
-          await syncIosUpdatesConfigurationAsync(projectDir, exp, { nonInteractive: false });
+          await syncIosUpdatesConfigurationAsync(projectDir, exp, projectId);
         }
       }
     }

packages/eas-cli/src/commands/build/index.ts

@@ -7,7 +7,10 @@ import path from 'path';
 
 import { BuildFlags, runBuildAndSubmitAsync } from '../../build/runBuildAndSubmit';
 import { UserInputResourceClass } from '../../build/types';
-import EasCommand from '../../commandUtils/EasCommand';
+import EasCommand, {
+  EASCommandLoggedInContext,
+  EASCommandProjectIdContext,
+} from '../../commandUtils/EasCommand';
 import { EasNonInteractiveAndJsonFlags } from '../../commandUtils/flags';
 import { StatuspageServiceName } from '../../graphql/generated';
 import Log, { link } from '../../log';
@@ -96,6 +99,11 @@ export default class Build extends EasCommand {
     ...EasNonInteractiveAndJsonFlags,
   };
 
+  static override contextDefinition = {
+    ...EASCommandLoggedInContext,
+    ...EASCommandProjectIdContext,
+  };
+
   async runAsync(): Promise<void> {
     const { flags: rawFlags } = await this.parse(Build);
 
@@ -104,6 +112,10 @@ export default class Build extends EasCommand {
     }
     const flags = this.sanitizeFlags(rawFlags);
 
+    const { actor, projectId } = await this.getContextAsync(Build, {
+      nonInteractive: flags.nonInteractive,
+    });
+
     const projectDir = await findProjectRootAsync();
 
     await handleDeprecatedEasJsonAsync(projectDir, flags.nonInteractive);
@@ -118,7 +130,7 @@ export default class Build extends EasCommand {
 
     const flagsWithPlatform = await this.ensurePlatformSelectedAsync(flags);
 
-    await runBuildAndSubmitAsync(projectDir, flagsWithPlatform);
+    await runBuildAndSubmitAsync(projectDir, flagsWithPlatform, actor, projectId);
   }
 
   private sanitizeFlags(

packages/eas-cli/src/commands/build/inspect.ts

@@ -5,7 +5,10 @@ import path from 'path';
 import { v4 as uuidv4 } from 'uuid';
 
 import { runBuildAndSubmitAsync } from '../../build/runBuildAndSubmit';
-import EasCommand from '../../commandUtils/EasCommand';
+import EasCommand, {
+  EASCommandLoggedInContext,
+  EASCommandProjectIdContext,
+} from '../../commandUtils/EasCommand';
 import Log from '../../log';
 import { ora } from '../../ora';
 import { RequestedPlatform } from '../../platform';
@@ -62,8 +65,17 @@ export default class BuildInspect extends EasCommand {
     }),
   };
 
+  static override contextDefinition = {
+    ...EASCommandLoggedInContext,
+    ...EASCommandProjectIdContext,
+  };
+
   async runAsync(): Promise<void> {
     const { flags } = await this.parse(BuildInspect);
+    const { actor, projectId } = await this.getContextAsync(BuildInspect, {
+      nonInteractive: false,
+    });
+
     const outputDirectory = path.resolve(process.cwd(), flags.output);
     const tmpWorkingdir = path.join(getTmpDirectory(), uuidv4());
 
@@ -83,7 +95,9 @@ export default class BuildInspect extends EasCommand {
     } else {
       const projectDir = await findProjectRootAsync();
       try {
-        await runBuildAndSubmitAsync(projectDir, {
+        await runBuildAndSubmitAsync(
+          projectDir,
+          {
             nonInteractive: false,
             wait: true,
             clearCache: false,
@@ -99,7 +113,10 @@ export default class BuildInspect extends EasCommand {
               workingdir: tmpWorkingdir,
               artifactsDir: path.join(tmpWorkingdir, 'artifacts'),
             },
-        });
+          },
+          actor,
+          projectId
+        );
         if (!flags.verbose) {
           Log.log(chalk.green('Build successful'));
         }

packages/eas-cli/src/commands/build/list.ts

@@ -2,7 +2,7 @@ import { Flags } from '@oclif/core';
 
 import { BUILDS_LIMIT, listAndRenderBuildsOnAppAsync } from '../../build/queries';
 import { BuildDistributionType, BuildStatus } from '../../build/types';
-import EasCommand from '../../commandUtils/EasCommand';
+import EasCommand, { EASCommandProjectIdContext } from '../../commandUtils/EasCommand';
 import { EasNonInteractiveAndJsonFlags } from '../../commandUtils/flags';
 import {
   EasPaginatedQueryFlags,
@@ -15,12 +15,7 @@ import {
   BuildStatus as GraphQLBuildStatus,
 } from '../../graphql/generated';
 import { RequestedPlatform } from '../../platform';
-import { getExpoConfig } from '../../project/expoConfig';
+import { getDisplayNameForProjectIdAsync } from '../../project/projectUtils';
-import {
-  findProjectRootAsync,
-  getDisplayNameForProjectIdAsync,
-  getProjectIdAsync,
-} from '../../project/projectUtils';
 import { enableJsonOutput } from '../../utils/json';
 
 export default class BuildList extends EasCommand {
@@ -60,6 +55,10 @@ export default class BuildList extends EasCommand {
     ...EasNonInteractiveAndJsonFlags,
   };
 
+  static override contextDefinition = {
+    ...EASCommandProjectIdContext,
+  };
+
   async runAsync(): Promise<void> {
     const { flags } = await this.parse(BuildList);
     const paginatedQueryOptions = getPaginatedQueryOptions(flags);
@@ -70,6 +69,9 @@ export default class BuildList extends EasCommand {
       distribution: buildDistribution,
       'non-interactive': nonInteractive,
     } = flags;
+    const { projectId } = await this.getContextAsync(BuildList, {
+      nonInteractive,
+    });
     if (jsonFlag) {
       enableJsonOutput();
     }
@@ -77,10 +79,6 @@ export default class BuildList extends EasCommand {
     const platform = toAppPlatform(requestedPlatform);
     const graphqlBuildStatus = toGraphQLBuildStatus(buildStatus);
     const graphqlBuildDistribution = toGraphQLBuildDistribution(buildDistribution);
-
-    const projectDir = await findProjectRootAsync();
-    const exp = getExpoConfig(projectDir);
-    const projectId = await getProjectIdAsync(exp, { nonInteractive });
     const displayName = await getDisplayNameForProjectIdAsync(projectId);
 
     await listAndRenderBuildsOnAppAsync({

packages/eas-cli/src/commands/build/version/set.ts

@@ -4,7 +4,10 @@ import { EasJsonAccessor, EasJsonUtils } from '@expo/eas-json';
 import { Flags } from '@oclif/core';
 import chalk from 'chalk';
 
-import EasCommand from '../../../commandUtils/EasCommand';
+import EasCommand, {
+  EASCommandLoggedInContext,
+  EASCommandProjectIdContext,
+} from '../../../commandUtils/EasCommand';
 import { AppVersionMutation } from '../../../graphql/mutations/AppVersionMutation';
 import { AppVersionQuery } from '../../../graphql/queries/AppVersionQuery';
 import { toAppPlatform } from '../../../graphql/types/AppPlatform';
@@ -17,7 +20,6 @@ import { BUILD_NUMBER_REQUIREMENTS, isValidBuildNumber } from '../../../project/
 import {
   findProjectRootAsync,
   getDisplayNameForProjectIdAsync,
-  getProjectIdAsync,
 } from '../../../project/projectUtils';
 import {
   ensureVersionSourceIsRemoteAsync,
@@ -42,8 +44,16 @@ export default class BuildVersionSetView extends EasCommand {
     }),
   };
 
+  static override contextDefinition = {
+    ...EASCommandLoggedInContext,
+    ...EASCommandProjectIdContext,
+  };
+
   public async runAsync(): Promise<void> {
     const { flags } = await this.parse(BuildVersionSetView);
+    const { actor, projectId } = await this.getContextAsync(BuildVersionSetView, {
+      nonInteractive: false,
+    });
 
     const projectDir = await findProjectRootAsync();
 
@@ -57,9 +67,6 @@ export default class BuildVersionSetView extends EasCommand {
     );
 
     const exp = getExpoConfig(projectDir, { env: profile.env });
-
-    // this command is always interactive (see prompt below)
-    const projectId = await getProjectIdAsync(exp, { nonInteractive: false });
     const displayName = await getDisplayNameForProjectIdAsync(projectId);
 
     validateAppConfigForRemoteVersionSource(exp, platform);
@@ -68,7 +75,8 @@ export default class BuildVersionSetView extends EasCommand {
       projectDir,
       exp,
       profile,
-      platform
+      platform,
+      actor
     );
     const remoteVersions = await AppVersionQuery.latestVersionAsync(
       projectId,

packages/eas-cli/src/commands/build/version/sync.ts

@@ -6,7 +6,10 @@ import chalk from 'chalk';
 
 import { updateNativeVersionsAsync as updateAndroidNativeVersionsAsync } from '../../../build/android/version';
 import { updateNativeVersionsAsync as updateIosNativeVersionsAsync } from '../../../build/ios/version';
-import EasCommand from '../../../commandUtils/EasCommand';
+import EasCommand, {
+  EASCommandLoggedInContext,
+  EASCommandProjectIdContext,
+} from '../../../commandUtils/EasCommand';
 import { AppVersionQuery } from '../../../graphql/queries/AppVersionQuery';
 import { toAppPlatform } from '../../../graphql/types/AppPlatform';
 import Log from '../../../log';
@@ -22,7 +25,7 @@ import { getExpoConfig } from '../../../project/expoConfig';
 import { resolveXcodeBuildContextAsync } from '../../../project/ios/scheme';
 import { resolveTargetsAsync } from '../../../project/ios/target';
 import { BUILD_NUMBER_REQUIREMENTS, isValidBuildNumber } from '../../../project/ios/versions';
-import { findProjectRootAsync, getProjectIdAsync } from '../../../project/projectUtils';
+import { findProjectRootAsync } from '../../../project/projectUtils';
 import {
   ensureVersionSourceIsRemoteAsync,
   getBuildVersionName,
@@ -56,8 +59,16 @@ export default class BuildVersionSyncView extends EasCommand {
     }),
   };
 
+  static override contextDefinition = {
+    ...EASCommandLoggedInContext,
+    ...EASCommandProjectIdContext,
+  };
+
   public async runAsync(): Promise<void> {
     const { flags } = await this.parse(BuildVersionSyncView);
+    const { actor, projectId } = await this.getContextAsync(BuildVersionSyncView, {
+      nonInteractive: true,
+    });
     const projectDir = await findProjectRootAsync();
 
     const requestedPlatform = await selectRequestedPlatformAsync(flags.platform);
@@ -74,9 +85,6 @@ export default class BuildVersionSyncView extends EasCommand {
     for (const profileInfo of buildProfiles) {
       const exp = getExpoConfig(projectDir, { env: profileInfo.profile.env });
 
-      // this command is always non-interactive
-      const projectId = await getProjectIdAsync(exp, { nonInteractive: true });
-
       validateAppConfigForRemoteVersionSource(exp, profileInfo.platform);
       const platformDisplayName = appPlatformDisplayNames[toAppPlatform(profileInfo.platform)];
 
@@ -84,7 +92,8 @@ export default class BuildVersionSyncView extends EasCommand {
         projectDir,
         exp,
         profileInfo.profile,
-        profileInfo.platform
+        profileInfo.platform,
+        actor
       );
       const remoteVersions = await AppVersionQuery.latestVersionAsync(
         projectId,

packages/eas-cli/src/commands/build/view.ts

@@ -1,16 +1,11 @@
 import { formatGraphQLBuild } from '../../build/utils/formatBuild';
-import EasCommand from '../../commandUtils/EasCommand';
+import EasCommand, { EASCommandProjectIdContext } from '../../commandUtils/EasCommand';
 import { EasJsonOnlyFlag } from '../../commandUtils/flags';
 import { BuildFragment } from '../../graphql/generated';
 import { BuildQuery } from '../../graphql/queries/BuildQuery';
 import Log from '../../log';
 import { ora } from '../../ora';
-import { getExpoConfig } from '../../project/expoConfig';
+import { getDisplayNameForProjectIdAsync } from '../../project/projectUtils';
-import {
-  findProjectRootAsync,
-  getDisplayNameForProjectIdAsync,
-  getProjectIdAsync,
-} from '../../project/projectUtils';
 import { enableJsonOutput, printJsonOnlyOutput } from '../../utils/json';
 
 export default class BuildView extends EasCommand {
@@ -22,20 +17,22 @@ export default class BuildView extends EasCommand {
     ...EasJsonOnlyFlag,
   };
 
+  static override contextDefinition = {
+    ...EASCommandProjectIdContext,
+  };
+
   async runAsync(): Promise<void> {
     const {
       args: { BUILD_ID: buildId },
       flags,
     } = await this.parse(BuildView);
+    const { projectId } = await this.getContextAsync(BuildView, {
+      nonInteractive: true,
+    });
     if (flags.json) {
       enableJsonOutput();
     }
 
-    const projectDir = await findProjectRootAsync();
-    const exp = getExpoConfig(projectDir);
-
-    // this command is always non-interactive
-    const projectId = await getProjectIdAsync(exp, { nonInteractive: true });
     const displayName = await getDisplayNameForProjectIdAsync(projectId);
 
     const spinner = ora().start('Fetching the build…');

packages/eas-cli/src/commands/channel/create.ts

@@ -2,7 +2,7 @@ import chalk from 'chalk';
 import gql from 'graphql-tag';
 
 import { BranchNotFoundError } from '../../branch/utils';
-import EasCommand from '../../commandUtils/EasCommand';
+import EasCommand, { EASCommandProjectIdContext } from '../../commandUtils/EasCommand';
 import { EasNonInteractiveAndJsonFlags } from '../../commandUtils/flags';
 import { graphqlClient, withErrorHandlingAsync } from '../../graphql/client';
 import {
@@ -11,12 +11,7 @@ import {
 } from '../../graphql/generated';
 import { BranchQuery } from '../../graphql/queries/BranchQuery';
 import Log from '../../log';
-import { getExpoConfig } from '../../project/expoConfig';
+import { getDisplayNameForProjectIdAsync } from '../../project/projectUtils';
-import {
-  findProjectRootAsync,
-  getDisplayNameForProjectIdAsync,
-  getProjectIdAsync,
-} from '../../project/projectUtils';
 import { promptAsync } from '../../prompts';
 import formatFields from '../../utils/formatFields';
 import { enableJsonOutput, printJsonOnlyOutput } from '../../utils/json';
@@ -75,19 +70,22 @@ export default class ChannelCreate extends EasCommand {
     ...EasNonInteractiveAndJsonFlags,
   };
 
+  static override contextDefinition = {
+    ...EASCommandProjectIdContext,
+  };
+
   async runAsync(): Promise<void> {
     let {
       args: { name: channelName },
       flags: { json: jsonFlag, 'non-interactive': nonInteractive },
     } = await this.parse(ChannelCreate);
+    const { projectId } = await this.getContextAsync(ChannelCreate, {
+      nonInteractive,
+    });
     if (jsonFlag) {
       enableJsonOutput();
     }
 
-    const projectDir = await findProjectRootAsync();
-    const exp = getExpoConfig(projectDir);
-    const projectId = await getProjectIdAsync(exp, { nonInteractive });
-
     if (!channelName) {
       const validationMessage = 'Channel name may not be empty.';
       if (nonInteractive) {

packages/eas-cli/src/commands/channel/delete.ts

@@ -1,7 +1,7 @@
 import gql from 'graphql-tag';
 
 import { selectChannelOnAppAsync } from '../../channel/queries';
-import EasCommand from '../../commandUtils/EasCommand';
+import EasCommand, { EASCommandProjectIdContext } from '../../commandUtils/EasCommand';
 import { EasNonInteractiveAndJsonFlags } from '../../commandUtils/flags';
 import { graphqlClient, withErrorHandlingAsync } from '../../graphql/client';
 import {
@@ -11,8 +11,6 @@ import {
 } from '../../graphql/generated';
 import { ChannelQuery } from '../../graphql/queries/ChannelQuery';
 import Log from '../../log';
-import { getExpoConfig } from '../../project/expoConfig';
-import { findProjectRootAsync, getProjectIdAsync } from '../../project/projectUtils';
 import { toggleConfirmAsync } from '../../prompts';
 import { enableJsonOutput, printJsonOnlyOutput } from '../../utils/json';
 
@@ -31,19 +29,22 @@ export default class ChannelDelete extends EasCommand {
     ...EasNonInteractiveAndJsonFlags,
   };
 
+  static override contextDefinition = {
+    ...EASCommandProjectIdContext,
+  };
+
   async runAsync(): Promise<void> {
     const {
       args: { name: nameArg },
       flags: { json: jsonFlag, 'non-interactive': nonInteractive },
     } = await this.parse(ChannelDelete);
+    const { projectId } = await this.getContextAsync(ChannelDelete, {
+      nonInteractive,
+    });
     if (jsonFlag) {
       enableJsonOutput();
     }
 
-    const projectDir = await findProjectRootAsync();
-    const exp = getExpoConfig(projectDir);
-    const projectId = await getProjectIdAsync(exp, { nonInteractive });
-
     let channelId, channelName;
     if (nameArg) {
       const { id, name } = await ChannelQuery.viewUpdateChannelAsync({

packages/eas-cli/src/commands/channel/edit.ts

@@ -4,7 +4,7 @@ import gql from 'graphql-tag';
 
 import { selectBranchOnAppAsync } from '../../branch/queries';
 import { selectChannelOnAppAsync } from '../../channel/queries';
-import EasCommand from '../../commandUtils/EasCommand';
+import EasCommand, { EASCommandProjectIdContext } from '../../commandUtils/EasCommand';
 import { EasNonInteractiveAndJsonFlags } from '../../commandUtils/flags';
 import { graphqlClient, withErrorHandlingAsync } from '../../graphql/client';
 import {
@@ -14,8 +14,6 @@ import {
 import { BranchQuery } from '../../graphql/queries/BranchQuery';
 import { ChannelQuery } from '../../graphql/queries/ChannelQuery';
 import Log from '../../log';
-import { getExpoConfig } from '../../project/expoConfig';
-import { findProjectRootAsync, getProjectIdAsync } from '../../project/projectUtils';
 import { enableJsonOutput, printJsonOnlyOutput } from '../../utils/json';
 
 export async function updateChannelBranchMappingAsync({
@@ -67,19 +65,22 @@ export default class ChannelEdit extends EasCommand {
     ...EasNonInteractiveAndJsonFlags,
   };
 
+  static override contextDefinition = {
+    ...EASCommandProjectIdContext,
+  };
+
   async runAsync(): Promise<void> {
     const {
       args,
       flags: { branch: branchFlag, json, 'non-interactive': nonInteractive },
     } = await this.parse(ChannelEdit);
+    const { projectId } = await this.getContextAsync(ChannelEdit, {
+      nonInteractive,
+    });
     if (json) {
       enableJsonOutput();
     }
 
-    const projectDir = await findProjectRootAsync();
-    const exp = getExpoConfig(projectDir);
-    const projectId = await getProjectIdAsync(exp, { nonInteractive });
-
     const existingChannel = args.name
       ? await ChannelQuery.viewUpdateChannelAsync({ appId: projectId, channelName: args.name })
       : await selectChannelOnAppAsync({

packages/eas-cli/src/commands/channel/list.ts

@@ -1,13 +1,11 @@
 import { CHANNELS_LIMIT, listAndRenderChannelsOnAppAsync } from '../../channel/queries';
-import EasCommand from '../../commandUtils/EasCommand';
+import EasCommand, { EASCommandProjectIdContext } from '../../commandUtils/EasCommand';
 import { EasNonInteractiveAndJsonFlags } from '../../commandUtils/flags';
 import {
   EasPaginatedQueryFlags,
   getLimitFlagWithCustomValues,
   getPaginatedQueryOptions,
 } from '../../commandUtils/pagination';
-import { getExpoConfig } from '../../project/expoConfig';
-import { findProjectRootAsync, getProjectIdAsync } from '../../project/projectUtils';
 import { enableJsonOutput } from '../../utils/json';
 
 export default class ChannelList extends EasCommand {
@@ -19,18 +17,21 @@ export default class ChannelList extends EasCommand {
     ...EasNonInteractiveAndJsonFlags,
   };
 
+  static override contextDefinition = {
+    ...EASCommandProjectIdContext,
+  };
+
   async runAsync(): Promise<void> {
     const { flags } = await this.parse(ChannelList);
     const paginatedQueryOptions = getPaginatedQueryOptions(flags);
     const { json: jsonFlag, 'non-interactive': nonInteractive } = flags;
+    const { projectId } = await this.getContextAsync(ChannelList, {
+      nonInteractive,
+    });
     if (jsonFlag) {
       enableJsonOutput();
     }
 
-    const projectDir = await findProjectRootAsync();
-    const exp = getExpoConfig(projectDir);
-    const projectId = await getProjectIdAsync(exp, { nonInteractive });
-
     await listAndRenderChannelsOnAppAsync({
       projectId,
       paginatedQueryOptions,

packages/eas-cli/src/commands/channel/rollout.ts

@@ -2,18 +2,13 @@ import { Flags } from '@oclif/core';
 import chalk from 'chalk';
 
 import { BranchMapping, getBranchMapping } from '../../channel/utils';
-import EasCommand from '../../commandUtils/EasCommand';
+import EasCommand, { EASCommandProjectIdContext } from '../../commandUtils/EasCommand';
 import { EasNonInteractiveAndJsonFlags } from '../../commandUtils/flags';
 import { UpdateBranch } from '../../graphql/generated';
 import { BranchQuery } from '../../graphql/queries/BranchQuery';
 import { ChannelQuery, UpdateChannelByNameObject } from '../../graphql/queries/ChannelQuery';
 import Log from '../../log';
-import { getExpoConfig } from '../../project/expoConfig';
+import { getDisplayNameForProjectIdAsync } from '../../project/projectUtils';
-import {
-  findProjectRootAsync,
-  getDisplayNameForProjectIdAsync,
-  getProjectIdAsync,
-} from '../../project/projectUtils';
 import { promptAsync, selectAsync } from '../../prompts';
 import { enableJsonOutput, printJsonOnlyOutput } from '../../utils/json';
 import { updateChannelBranchMappingAsync } from './edit';
@@ -316,6 +311,10 @@ export default class ChannelRollout extends EasCommand {
     ...EasNonInteractiveAndJsonFlags,
   };
 
+  static override contextDefinition = {
+    ...EASCommandProjectIdContext,
+  };
+
   async runAsync(): Promise<void> {
     const {
       args: { channel: channelName },
@@ -327,13 +326,13 @@ export default class ChannelRollout extends EasCommand {
         'non-interactive': nonInteractive,
       },
     } = await this.parse(ChannelRollout);
+    const { projectId } = await this.getContextAsync(ChannelRollout, {
+      nonInteractive,
+    });
     if (jsonFlag) {
       enableJsonOutput();
     }
 
-    const projectDir = await findProjectRootAsync();
-    const exp = getExpoConfig(projectDir);
-    const projectId = await getProjectIdAsync(exp, { nonInteractive });
     const projectDisplayName = await getDisplayNameForProjectIdAsync(projectId);
 
     const channel = await ChannelQuery.viewUpdateChannelAsync({

packages/eas-cli/src/commands/channel/view.ts

@@ -4,11 +4,9 @@ import {
   listAndRenderBranchesAndUpdatesOnChannelAsync,
   selectChannelOnAppAsync,
 } from '../../channel/queries';
-import EasCommand from '../../commandUtils/EasCommand';
+import EasCommand, { EASCommandProjectIdContext } from '../../commandUtils/EasCommand';
 import { EasNonInteractiveAndJsonFlags } from '../../commandUtils/flags';
 import { EasPaginatedQueryFlags, getPaginatedQueryOptions } from '../../commandUtils/pagination';
-import { getExpoConfig } from '../../project/expoConfig';
-import { findProjectRootAsync, getProjectIdAsync } from '../../project/projectUtils';
 import { enableJsonOutput } from '../../utils/json';
 
 export default class ChannelView extends EasCommand {
@@ -27,6 +25,10 @@ export default class ChannelView extends EasCommand {
     ...EasPaginatedQueryFlags,
   };
 
+  static override contextDefinition = {
+    ...EASCommandProjectIdContext,
+  };
+
   async runAsync(): Promise<void> {
     let {
       args: { name: channelName },
@@ -34,14 +36,13 @@ export default class ChannelView extends EasCommand {
     } = await this.parse(ChannelView);
     const paginatedQueryOptions = getPaginatedQueryOptions(flags);
     const { json: jsonFlag, 'non-interactive': nonInteractive } = flags;
+    const { projectId } = await this.getContextAsync(ChannelView, {
+      nonInteractive,
+    });
     if (jsonFlag) {
       enableJsonOutput();
     }
 
-    const projectDir = await findProjectRootAsync();
-    const exp = getExpoConfig(projectDir);
-    const projectId = await getProjectIdAsync(exp, { nonInteractive });
-
     if (!channelName) {
       const validationMessage = 'A channel name is required to view a specific channel.';
       if (nonInteractive) {

packages/eas-cli/src/commands/config.ts

@@ -4,7 +4,7 @@ import { EasJsonAccessor, EasJsonUtils } from '@expo/eas-json';
 import { Flags } from '@oclif/core';
 import chalk from 'chalk';
 
-import EasCommand from '../commandUtils/EasCommand';
+import EasCommand, { CommandConfiguration } from '../commandUtils/EasCommand';
 import { toAppPlatform } from '../graphql/types/AppPlatform';
 import Log from '../log';
 import { appPlatformEmojis } from '../platform';
@@ -25,7 +25,9 @@ export default class Config extends EasCommand {
     }),
   };
 
-  protected override requiresAuthentication = false;
+  protected override commandConfiguration: CommandConfiguration = {
+    allowUnauthenticated: true,
+  };
 
   async runAsync(): Promise<void> {
     const { flags } = await this.parse(Config);

packages/eas-cli/src/commands/credentials.ts

@@ -1,7 +1,12 @@
 import { Flags } from '@oclif/core';
 
-import EasCommand from '../commandUtils/EasCommand';
+import EasCommand, {
+  EASCommandLoggedInContext,
+  EASCommandProjectIdContext,
+} from '../commandUtils/EasCommand';
 import { SelectPlatform } from '../credentials/manager/SelectPlatform';
+import { getExpoConfig } from '../project/expoConfig';
+import { findProjectRootAsync } from '../project/projectUtils';
 
 export default class Credentials extends EasCommand {
   static override description = 'manage credentials';
@@ -10,8 +15,18 @@ export default class Credentials extends EasCommand {
     platform: Flags.enum({ char: 'p', options: ['android', 'ios'] }),
   };
 
+  static override contextDefinition = {
+    ...EASCommandLoggedInContext,
+    ...EASCommandProjectIdContext,
+  };
+
   async runAsync(): Promise<void> {
     const { flags } = await this.parse(Credentials);
-    await new SelectPlatform(flags.platform).runAsync();
+    const { actor, projectId } = await this.getContextAsync(Credentials, { nonInteractive: false });
+
+    const projectDir = await findProjectRootAsync();
+    const exp = getExpoConfig(projectDir);
+
+    await new SelectPlatform(actor, { projectId, exp }, flags.platform).runAsync();
   }
 }

packages/eas-cli/src/commands/device/create.ts

@@ -1,17 +1,26 @@
-import EasCommand from '../../commandUtils/EasCommand';
+import EasCommand, {
+  EASCommandLoggedInContext,
+  EASCommandProjectIdContext,
+} from '../../commandUtils/EasCommand';
 import AppStoreApi from '../../credentials/ios/appstore/AppStoreApi';
 import { createContextAsync } from '../../devices/context';
 import DeviceManager from '../../devices/manager';
-import { ensureLoggedInAsync } from '../../user/actions';
 
 export default class DeviceCreate extends EasCommand {
   static override description = 'register new Apple Devices to use for internal distribution';
 
+  static override contextDefinition = {
+    ...EASCommandLoggedInContext,
+    ...EASCommandProjectIdContext,
+  };
+
   async runAsync(): Promise<void> {
     // this command is interactive by design
-    const user = await ensureLoggedInAsync({ nonInteractive: false });
+    const { actor, projectId } = await this.getContextAsync(DeviceCreate, {
+      nonInteractive: false,
+    });
 
-    const ctx = await createContextAsync({ appStore: new AppStoreApi(), user });
+    const ctx = await createContextAsync({ appStore: new AppStoreApi(), user: actor, projectId });
     const manager = new DeviceManager(ctx);
     await manager.createAsync();
   }

packages/eas-cli/src/commands/device/delete.ts

@@ -2,7 +2,7 @@ import { Device, DeviceStatus } from '@expo/apple-utils';
 import { Flags } from '@oclif/core';
 import assert from 'assert';
 
-import EasCommand from '../../commandUtils/EasCommand';
+import EasCommand, { EASCommandProjectIdContext } from '../../commandUtils/EasCommand';
 import { chooseDevicesToDeleteAsync } from '../../credentials/ios/actions/DeviceUtils';
 import { AppleDeviceMutation } from '../../credentials/ios/api/graphql/mutations/AppleDeviceMutation';
 import {
@@ -16,12 +16,7 @@ import formatDevice from '../../devices/utils/formatDevice';
 import { AppleDevice, Maybe } from '../../graphql/generated';
 import Log from '../../log';
 import { ora } from '../../ora';
-import { getExpoConfig } from '../../project/expoConfig';
+import { getOwnerAccountForProjectIdAsync } from '../../project/projectUtils';
-import {
-  findProjectRootAsync,
-  getOwnerAccountForProjectIdAsync,
-  getProjectIdAsync,
-} from '../../project/projectUtils';
 import { promptAsync, toggleConfirmAsync } from '../../prompts';
 
 export default class DeviceDelete extends EasCommand {
@@ -32,15 +27,18 @@ export default class DeviceDelete extends EasCommand {
     udid: Flags.string({ multiple: true }),
   };
 
+  static override contextDefinition = {
+    ...EASCommandProjectIdContext,
+  };
+
   async runAsync(): Promise<void> {
     let {
       flags: { 'apple-team-id': appleTeamIdentifier, udid: udids },
     } = await this.parse(DeviceDelete);
+    const { projectId } = await this.getContextAsync(DeviceDelete, {
+      nonInteractive: false,
+    });
 
-    const projectDir = await findProjectRootAsync();
-    const exp = getExpoConfig(projectDir);
-    // this command is interactive by design
-    const projectId = await getProjectIdAsync(exp, { nonInteractive: false });
     const account = await getOwnerAccountForProjectIdAsync(projectId);
 
     if (!appleTeamIdentifier) {

packages/eas-cli/src/commands/device/list.ts

@@ -2,18 +2,13 @@ import { Flags } from '@oclif/core';
 import assert from 'assert';
 import chalk from 'chalk';
 
-import EasCommand from '../../commandUtils/EasCommand';
+import EasCommand, { EASCommandProjectIdContext } from '../../commandUtils/EasCommand';
 import { AppleDeviceQuery } from '../../credentials/ios/api/graphql/queries/AppleDeviceQuery';
 import { AppleTeamQuery } from '../../credentials/ios/api/graphql/queries/AppleTeamQuery';
 import formatDevice from '../../devices/utils/formatDevice';
 import Log from '../../log';
 import { Ora, ora } from '../../ora';
-import { getExpoConfig } from '../../project/expoConfig';
+import { getOwnerAccountForProjectIdAsync } from '../../project/projectUtils';
-import {
-  findProjectRootAsync,
-  getOwnerAccountForProjectIdAsync,
-  getProjectIdAsync,
-} from '../../project/projectUtils';
 import { promptAsync } from '../../prompts';
 
 export default class BuildList extends EasCommand {
@@ -23,14 +18,16 @@ export default class BuildList extends EasCommand {
     'apple-team-id': Flags.string(),
   };
 
+  static override contextDefinition = {
+    ...EASCommandProjectIdContext,
+  };
+
   async runAsync(): Promise<void> {
     let appleTeamIdentifier = (await this.parse(BuildList)).flags['apple-team-id'];
+    const { projectId } = await this.getContextAsync(BuildList, {
+      nonInteractive: false,
+    });
 
-    const projectDir = await findProjectRootAsync();
-    const exp = getExpoConfig(projectDir);
-
-    // this command is interactive by design
-    const projectId = await getProjectIdAsync(exp, { nonInteractive: false });
     const account = await getOwnerAccountForProjectIdAsync(projectId);
 
     let spinner: Ora;

packages/eas-cli/src/commands/device/view.ts

@@ -1,20 +1,19 @@
-import EasCommand from '../../commandUtils/EasCommand';
+import EasCommand, { EASCommandProjectIdContext } from '../../commandUtils/EasCommand';
 import { AppleDeviceQuery } from '../../credentials/ios/api/graphql/queries/AppleDeviceQuery';
 import formatDevice from '../../devices/utils/formatDevice';
 import Log from '../../log';
 import { ora } from '../../ora';
-import { getExpoConfig } from '../../project/expoConfig';
+import { getOwnerAccountForProjectIdAsync } from '../../project/projectUtils';
-import {
-  findProjectRootAsync,
-  getOwnerAccountForProjectIdAsync,
-  getProjectIdAsync,
-} from '../../project/projectUtils';
 
 export default class DeviceView extends EasCommand {
   static override description = 'view a device for your project';
 
   static override args = [{ name: 'UDID' }];
 
+  static override contextDefinition = {
+    ...EASCommandProjectIdContext,
+  };
+
   async runAsync(): Promise<void> {
     const { UDID } = (await this.parse(DeviceView)).args;
 
@@ -31,12 +30,9 @@ If you are not sure what is the UDID of the device you are looking for, run:
       );
       throw new Error('Device UDID is missing');
     }
-
+    const { projectId } = await this.getContextAsync(DeviceView, {
-    const projectDir = await findProjectRootAsync();
+      nonInteractive: true,
-    const exp = getExpoConfig(projectDir);
+    });
-
-    // this command is non-interactive by design
-    const projectId = await getProjectIdAsync(exp, { nonInteractive: true });
     const account = await getOwnerAccountForProjectIdAsync(projectId);
 
     const spinner = ora().start(`Fetching device details for ${UDID}…`);

packages/eas-cli/src/commands/diagnostics.ts

@@ -1,7 +1,7 @@
 import { Platform } from '@expo/eas-build-job';
 import envinfo from 'envinfo';
 
-import EasCommand from '../commandUtils/EasCommand';
+import EasCommand, { CommandConfiguration } from '../commandUtils/EasCommand';
 import Log from '../log';
 import { findProjectRootAsync } from '../project/projectUtils';
 import { resolveWorkflowAsync } from '../project/workflow';
@@ -10,7 +10,9 @@ import { easCliVersion } from '../utils/easCli';
 export default class Diagnostics extends EasCommand {
   static override description = 'display environment info';
 
-  protected override requiresAuthentication = false;
+  protected override commandConfiguration: CommandConfiguration = {
+    allowUnauthenticated: true,
+  };
 
   async runAsync(): Promise<void> {
     const info = await envinfo.run(

packages/eas-cli/src/commands/metadata/pull.ts

@@ -4,14 +4,16 @@ import chalk from 'chalk';
 import path from 'path';
 
 import { ensureProjectConfiguredAsync } from '../../build/configure';
-import EasCommand from '../../commandUtils/EasCommand';
+import EasCommand, {
+  EASCommandLoggedInContext,
+  EASCommandProjectIdContext,
+} from '../../commandUtils/EasCommand';
 import { CredentialsContext } from '../../credentials/context';
 import Log, { learnMore } from '../../log';
 import { createMetadataContextAsync } from '../../metadata/context';
 import { downloadMetadataAsync } from '../../metadata/download';
 import { handleMetadataError } from '../../metadata/errors';
-import { findProjectRootAsync, getProjectIdAsync } from '../../project/projectUtils';
+import { findProjectRootAsync } from '../../project/projectUtils';
-import { ensureLoggedInAsync } from '../../user/actions';
 
 export default class MetadataPull extends EasCommand {
   static override description = 'generate the local store configuration from the app stores';
@@ -24,21 +26,29 @@ export default class MetadataPull extends EasCommand {
     }),
   };
 
+  static override contextDefinition = {
+    ...EASCommandProjectIdContext,
+    ...EASCommandLoggedInContext,
+  };
+
   async runAsync(): Promise<void> {
     Log.warn('EAS Metadata is in beta and subject to breaking changes.');
 
     const { flags } = await this.parse(MetadataPull);
+    const { actor, projectId } = await this.getContextAsync(MetadataPull, {
+      nonInteractive: false,
+    });
+
     const projectDir = await findProjectRootAsync();
     const { exp } = getConfig(projectDir, { skipSDKVersionRequirement: true });
 
     // this command is interactive (all nonInteractive flags passed to utility functions are false)
-    await getProjectIdAsync(exp, { nonInteractive: false });
     await ensureProjectConfiguredAsync({ projectDir, nonInteractive: false });
 
     const credentialsCtx = new CredentialsContext({
-      exp,
+      projectInfo: { exp, projectId },
       projectDir,
-      user: await ensureLoggedInAsync({ nonInteractive: false }),
+      user: actor,
       nonInteractive: false,
     });
 

packages/eas-cli/src/commands/metadata/push.ts

@@ -2,14 +2,16 @@ import { getConfig } from '@expo/config';
 import { Flags } from '@oclif/core';
 
 import { ensureProjectConfiguredAsync } from '../../build/configure';
-import EasCommand from '../../commandUtils/EasCommand';
+import EasCommand, {
+  EASCommandLoggedInContext,
+  EASCommandProjectIdContext,
+} from '../../commandUtils/EasCommand';
 import { CredentialsContext } from '../../credentials/context';
 import Log, { learnMore } from '../../log';
 import { createMetadataContextAsync } from '../../metadata/context';
 import { handleMetadataError } from '../../metadata/errors';
 import { uploadMetadataAsync } from '../../metadata/upload';
-import { findProjectRootAsync, getProjectIdAsync } from '../../project/projectUtils';
+import { findProjectRootAsync } from '../../project/projectUtils';
-import { ensureLoggedInAsync } from '../../user/actions';
 
 export default class MetadataPush extends EasCommand {
   static override description = 'sync the local store configuration to the app stores';
@@ -22,21 +24,29 @@ export default class MetadataPush extends EasCommand {
     }),
   };
 
+  static override contextDefinition = {
+    ...EASCommandProjectIdContext,
+    ...EASCommandLoggedInContext,
+  };
+
   async runAsync(): Promise<void> {
     Log.warn('EAS Metadata is in beta and subject to breaking changes.');
 
     const { flags } = await this.parse(MetadataPush);
+    const { actor, projectId } = await this.getContextAsync(MetadataPush, {
+      nonInteractive: false,
+    });
+
     const projectDir = await findProjectRootAsync();
     const { exp } = getConfig(projectDir, { skipSDKVersionRequirement: true });
 
     // this command is interactive (all nonInteractive flags passed to utility functions are false)
-    await getProjectIdAsync(exp, { nonInteractive: false });
     await ensureProjectConfiguredAsync({ projectDir, nonInteractive: false });
 
     const credentialsCtx = new CredentialsContext({
-      exp,
+      projectInfo: { exp, projectId },
       projectDir,
-      user: await ensureLoggedInAsync({ nonInteractive: false }),
+      user: actor,
       nonInteractive: false,
     });
 

packages/eas-cli/src/commands/open.ts

@@ -1,25 +1,26 @@
 import openBrowserAsync from 'better-opn';
 
 import { getProjectDashboardUrl } from '../build/utils/url';
-import EasCommand from '../commandUtils/EasCommand';
+import EasCommand, { EASCommandProjectIdContext } from '../commandUtils/EasCommand';
 import { ora } from '../ora';
 import { getExpoConfig } from '../project/expoConfig';
-import {
+import { findProjectRootAsync, getOwnerAccountForProjectIdAsync } from '../project/projectUtils';
-  findProjectRootAsync,
-  getOwnerAccountForProjectIdAsync,
-  getProjectIdAsync,
-} from '../project/projectUtils';
 
 export default class Open extends EasCommand {
   static override description = 'open the project page in a web browser';
 
+  static override contextDefinition = {
+    ...EASCommandProjectIdContext,
+  };
+
   async runAsync(): Promise<void> {
+    // this command is interactive by nature (only really run by humans in a terminal)
+    const { projectId } = await this.getContextAsync(Open, {
+      nonInteractive: false,
+    });
     const projectDir = await findProjectRootAsync();
     const exp = getExpoConfig(projectDir);
 
-    // this command is interactive by nature (only really run by humans in a terminal)
-    // this ensures the project exists before opening the browser
-    const projectId = await getProjectIdAsync(exp, { nonInteractive: false });
     const account = await getOwnerAccountForProjectIdAsync(projectId);
 
     const projectName = exp.slug;

packages/eas-cli/src/commands/project/info.ts

@@ -1,11 +1,9 @@
 import gql from 'graphql-tag';
 
-import EasCommand from '../../commandUtils/EasCommand';
+import EasCommand, { EASCommandProjectIdContext } from '../../commandUtils/EasCommand';
 import { graphqlClient, withErrorHandlingAsync } from '../../graphql/client';
 import { AppInfoQuery, AppInfoQueryVariables } from '../../graphql/generated';
 import Log from '../../log';
-import { getExpoConfig } from '../../project/expoConfig';
-import { findProjectRootAsync, getProjectIdAsync } from '../../project/projectUtils';
 import formatFields from '../../utils/formatFields';
 
 async function projectInfoByIdAsync(appId: string): Promise<AppInfoQuery> {
@@ -34,12 +32,14 @@ async function projectInfoByIdAsync(appId: string): Promise<AppInfoQuery> {
 export default class ProjectInfo extends EasCommand {
   static override description = 'information about the current project';
 
-  async runAsync(): Promise<void> {
+  static override contextDefinition = {
-    const projectDir = await findProjectRootAsync();
+    ...EASCommandProjectIdContext,
-    const exp = getExpoConfig(projectDir);
+  };
 
-    // this command is non-interactive by design
+  async runAsync(): Promise<void> {
-    const projectId = await getProjectIdAsync(exp, { nonInteractive: true });
+    const { projectId } = await this.getContextAsync(ProjectInfo, {
+      nonInteractive: true,
+    });
 
     const { app } = await projectInfoByIdAsync(projectId);
     if (!app) {

packages/eas-cli/src/commands/project/init.ts

@@ -4,7 +4,7 @@ import nullthrows from 'nullthrows';
 import terminalLink from 'terminal-link';
 
 import { getProjectDashboardUrl } from '../../build/utils/url';
-import EasCommand from '../../commandUtils/EasCommand';
+import EasCommand, { EASCommandLoggedInContext } from '../../commandUtils/EasCommand';
 import { AppPrivacy, Role } from '../../graphql/generated';
 import { AppMutation } from '../../graphql/mutations/AppMutation';
 import Log from '../../log';
@@ -17,7 +17,7 @@ import {
   toAppPrivacy,
 } from '../../project/projectUtils';
 import { confirmAsync, promptAsync } from '../../prompts';
-import { ensureLoggedInAsync } from '../../user/actions';
+import { Actor } from '../../user/User';
 
 type InitializeMethodOptions = {
   force: boolean;
@@ -43,6 +43,10 @@ export default class ProjectInit extends EasCommand {
     }),
   };
 
+  static override contextDefinition = {
+    ...EASCommandLoggedInContext,
+  };
+
   private static async saveProjectIdAndLogSuccessAsync(
     projectDir: string,
     projectId: string
@@ -97,7 +101,7 @@ export default class ProjectInit extends EasCommand {
     }
   }
 
-  private static async initializeWithInteractiveSelectionAsync(): Promise<void> {
+  private static async initializeWithInteractiveSelectionAsync(actor: Actor): Promise<void> {
     const projectDir = await findProjectRootAsync();
     const exp = getExpoConfig(projectDir);
     const existingProjectId = exp.extra?.eas?.projectId;
@@ -111,7 +115,6 @@ export default class ProjectInit extends EasCommand {
       return;
     }
 
-    const actor = await ensureLoggedInAsync({ nonInteractive: false });
     const allAccounts = actor.accounts;
     const accountNamesWhereUserHasSufficientPermissionsToCreateApp = new Set(
       allAccounts
@@ -215,11 +218,12 @@ export default class ProjectInit extends EasCommand {
     const {
       flags: { id, force, 'non-interactive': nonInteractive },
     } = await this.parse(ProjectInit);
+    const { actor } = await this.getContextAsync(ProjectInit, { nonInteractive });
 
     if (id) {
       await ProjectInit.initializeWithExplicitIDAsync(id, { force, nonInteractive });
     } else {
-      await ProjectInit.initializeWithInteractiveSelectionAsync();
+      await ProjectInit.initializeWithInteractiveSelectionAsync(actor);
     }
   }
 }

packages/eas-cli/src/commands/secret/create.ts

@@ -4,7 +4,7 @@ import chalk from 'chalk';
 import fs from 'fs-extra';
 import path from 'path';
 
-import EasCommand from '../../commandUtils/EasCommand';
+import EasCommand, { EASCommandProjectIdContext } from '../../commandUtils/EasCommand';
 import { EASNonInteractiveFlag } from '../../commandUtils/flags';
 import { EnvironmentSecretMutation } from '../../graphql/mutations/EnvironmentSecretMutation';
 import {
@@ -16,12 +16,9 @@ import {
   SecretTypeToEnvironmentSecretType,
 } from '../../graphql/types/EnvironmentSecret';
 import Log from '../../log';
-import { getExpoConfig } from '../../project/expoConfig';
 import {
-  findProjectRootAsync,
   getDisplayNameForProjectIdAsync,
   getOwnerAccountForProjectIdAsync,
-  getProjectIdAsync,
 } from '../../project/projectUtils';
 import { promptAsync, selectAsync } from '../../prompts';
 
@@ -52,6 +49,10 @@ export default class EnvironmentSecretCreate extends EasCommand {
     ...EASNonInteractiveFlag,
   };
 
+  static override contextDefinition = {
+    ...EASCommandProjectIdContext,
+  };
+
   async runAsync(): Promise<void> {
     let {
       flags: {
@@ -63,10 +64,10 @@ export default class EnvironmentSecretCreate extends EasCommand {
         'non-interactive': nonInteractive,
       },
     } = await this.parse(EnvironmentSecretCreate);
+    const { projectId } = await this.getContextAsync(EnvironmentSecretCreate, {
+      nonInteractive,
+    });
 
-    const projectDir = await findProjectRootAsync();
-    const exp = getExpoConfig(projectDir);
-    const projectId = await getProjectIdAsync(exp, { nonInteractive });
     const projectDisplayName = await getDisplayNameForProjectIdAsync(projectId);
     const ownerAccount = await getOwnerAccountForProjectIdAsync(projectId);
 

packages/eas-cli/src/commands/secret/delete.ts

@@ -1,6 +1,6 @@
 import { Flags } from '@oclif/core';
 
-import EasCommand from '../../commandUtils/EasCommand';
+import EasCommand, { EASCommandProjectIdContext } from '../../commandUtils/EasCommand';
 import { EASNonInteractiveFlag } from '../../commandUtils/flags';
 import { EnvironmentSecretMutation } from '../../graphql/mutations/EnvironmentSecretMutation';
 import {
@@ -9,8 +9,6 @@ import {
   EnvironmentSecretsQuery,
 } from '../../graphql/queries/EnvironmentSecretsQuery';
 import Log from '../../log';
-import { getExpoConfig } from '../../project/expoConfig';
-import { findProjectRootAsync, getProjectIdAsync } from '../../project/projectUtils';
 import { promptAsync, toggleConfirmAsync } from '../../prompts';
 
 export default class EnvironmentSecretDelete extends EasCommand {
@@ -23,16 +21,19 @@ export default class EnvironmentSecretDelete extends EasCommand {
     ...EASNonInteractiveFlag,
   };
 
+  static override contextDefinition = {
+    ...EASCommandProjectIdContext,
+  };
+
   async runAsync(): Promise<void> {
     let {
       flags: { id, 'non-interactive': nonInteractive },
     } = await this.parse(EnvironmentSecretDelete);
+    const { projectId } = await this.getContextAsync(EnvironmentSecretDelete, {
+      nonInteractive,
+    });
     let secret: EnvironmentSecretWithScope | undefined;
 
-    const projectDir = await findProjectRootAsync();
-    const exp = getExpoConfig(projectDir);
-    const projectId = await getProjectIdAsync(exp, { nonInteractive });
-
     if (!id) {
       const validationMessage = 'You must select which secret to delete.';
       if (nonInteractive) {

packages/eas-cli/src/commands/secret/list.ts

@@ -2,26 +2,23 @@ import chalk from 'chalk';
 import Table from 'cli-table3';
 import dateFormat from 'dateformat';
 
-import EasCommand from '../../commandUtils/EasCommand';
+import EasCommand, { EASCommandProjectIdContext } from '../../commandUtils/EasCommand';
 import { EnvironmentSecretsQuery } from '../../graphql/queries/EnvironmentSecretsQuery';
 import { EnvironmentSecretTypeToSecretType } from '../../graphql/types/EnvironmentSecret';
 import Log from '../../log';
-import { getExpoConfig } from '../../project/expoConfig';
-import { findProjectRootAsync, getProjectIdAsync } from '../../project/projectUtils';
 
 export default class EnvironmentSecretList extends EasCommand {
   static override description = 'list environment secrets available for your current app';
 
+  static override contextDefinition = {
+    ...EASCommandProjectIdContext,
+  };
+
   async runAsync(): Promise<void> {
-    const projectDir = await findProjectRootAsync();
+    const { projectId } = await this.getContextAsync(EnvironmentSecretList, {
-    if (!projectDir) {
+      nonInteractive: true,
-      throw new Error("Run this command inside your project's directory");
+    });
-    }
 
-    const exp = getExpoConfig(projectDir);
-
-    // this command is non-interacive by design
-    const projectId = await getProjectIdAsync(exp, { nonInteractive: true });
     const secrets = await EnvironmentSecretsQuery.allAsync(projectId);
 
     const table = new Table({

packages/eas-cli/src/commands/submit.ts

@@ -2,7 +2,10 @@ import { EasJsonAccessor } from '@expo/eas-json';
 import { Errors, Flags } from '@oclif/core';
 import chalk from 'chalk';
 
-import EasCommand from '../commandUtils/EasCommand';
+import EasCommand, {
+  EASCommandLoggedInContext,
+  EASCommandProjectIdContext,
+} from '../commandUtils/EasCommand';
 import { StatuspageServiceName, SubmissionFragment } from '../graphql/generated';
 import { toAppPlatform } from '../graphql/types/AppPlatform';
 import Log from '../log';
@@ -13,8 +16,7 @@ import {
   selectRequestedPlatformAsync,
   toPlatforms,
 } from '../platform';
-import { getExpoConfig } from '../project/expoConfig';
+import { findProjectRootAsync } from '../project/projectUtils';
-import { findProjectRootAsync, getProjectIdAsync } from '../project/projectUtils';
 import { SubmitArchiveFlags, createSubmissionContextAsync } from '../submit/context';
 import {
   exitWithNonZeroCodeIfSomeSubmissionsDidntFinish,
@@ -91,14 +93,18 @@ export default class Submit extends EasCommand {
     }),
   };
 
+  static override contextDefinition = {
+    ...EASCommandLoggedInContext,
+    ...EASCommandProjectIdContext,
+  };
+
   async runAsync(): Promise<void> {
     const { flags: rawFlags } = await this.parse(Submit);
+    const { actor, projectId } = await this.getContextAsync(Submit, { nonInteractive: false });
 
     const flags = this.sanitizeFlags(rawFlags);
 
     const projectDir = await findProjectRootAsync();
-    const exp = getExpoConfig(projectDir);
-    const projectId = await getProjectIdAsync(exp, { nonInteractive: flags.nonInteractive });
 
     await maybeWarnAboutEasOutagesAsync([StatuspageServiceName.EasSubmit]);
 
@@ -121,6 +127,7 @@ export default class Submit extends EasCommand {
         profile: submissionProfile.profile,
         archiveFlags: flagsWithPlatform.archiveFlags,
         nonInteractive: flagsWithPlatform.nonInteractive,
+        actor,
       });
 
       if (submissionProfiles.length > 1) {

packages/eas-cli/src/commands/update/configure.ts

@@ -5,14 +5,13 @@ import assert from 'assert';
 import chalk from 'chalk';
 
 import { getEASUpdateURL } from '../../api';
-import EasCommand from '../../commandUtils/EasCommand';
+import EasCommand, { EASCommandProjectIdContext } from '../../commandUtils/EasCommand';
 import { AppPlatform } from '../../graphql/generated';
 import Log, { learnMore } from '../../log';
 import { RequestedPlatform, appPlatformDisplayNames } from '../../platform';
 import { getExpoConfig } from '../../project/expoConfig';
 import {
   findProjectRootAsync,
-  getProjectIdAsync,
   installExpoUpdatesAsync,
   isExpoUpdatesInstalledOrAvailable,
 } from '../../project/projectUtils';
@@ -35,11 +34,18 @@ export default class UpdateConfigure extends EasCommand {
     }),
   };
 
+  static override contextDefinition = {
+    ...EASCommandProjectIdContext,
+  };
+
   async runAsync(): Promise<void> {
     Log.log(
       '💡 The following process will configure your project to run EAS Update. These changes only apply to your local project files and you can safely revert them at any time.'
     );
     const { flags } = await this.parse(UpdateConfigure);
+    const { projectId } = await this.getContextAsync(UpdateConfigure, {
+      nonInteractive: true,
+    });
     const platform = flags.platform as RequestedPlatform;
     const projectDir = await findProjectRootAsync();
     const exp = getExpoConfig(projectDir);
@@ -61,6 +67,7 @@ export default class UpdateConfigure extends EasCommand {
         android: androidWorkflow,
         ios: iosWorkflow,
       },
+      projectId,
     });
     Log.withTick(`Configured ${chalk.bold('app.json')} for EAS Update`);
 
@@ -69,14 +76,14 @@ export default class UpdateConfigure extends EasCommand {
       [RequestedPlatform.Android, RequestedPlatform.All].includes(platform) &&
       androidWorkflow === Workflow.GENERIC
     ) {
-      await syncAndroidUpdatesConfigurationAsync(projectDir, updatedExp, { nonInteractive: true });
+      await syncAndroidUpdatesConfigurationAsync(projectDir, updatedExp, projectId);
       Log.withTick(`Configured ${chalk.bold('AndroidManifest.xml')} for EAS Update`);
     }
     if (
       [RequestedPlatform.Ios, RequestedPlatform.All].includes(platform) &&
       iosWorkflow === Workflow.GENERIC
     ) {
-      await syncIosUpdatesConfigurationAsync(projectDir, updatedExp, { nonInteractive: true });
+      await syncIosUpdatesConfigurationAsync(projectDir, updatedExp, projectId);
       Log.withTick(`Configured ${chalk.bold('Expo.plist')} for EAS Update`);
     }
 
@@ -90,6 +97,7 @@ async function configureAppJSONForEASUpdateAsync({
   exp,
   platform,
   workflows,
+  projectId,
 }: {
   projectDir: string;
   exp: ExpoConfig;
@@ -97,9 +105,9 @@ async function configureAppJSONForEASUpdateAsync({
   workflows: {
     [key in RequestedPlatform.Android | RequestedPlatform.Ios]: Workflow;
   };
+  projectId: string;
 }): Promise<ExpoConfig> {
   // this command is non-interactive in the way it was designed
-  const projectId = await getProjectIdAsync(exp, { nonInteractive: true });
   const easUpdateURL = getEASUpdateURL(projectId);
   const updates = { ...exp.updates, url: easUpdateURL };
 

packages/eas-cli/src/commands/update/index.ts

@@ -10,7 +10,7 @@ import { getEASUpdateURL } from '../../api';
 import { selectBranchOnAppAsync } from '../../branch/queries';
 import { BranchNotFoundError, getDefaultBranchNameAsync } from '../../branch/utils';
 import { getUpdateGroupUrl } from '../../build/utils/url';
-import EasCommand from '../../commandUtils/EasCommand';
+import EasCommand, { EASCommandProjectIdContext } from '../../commandUtils/EasCommand';
 import { EasNonInteractiveAndJsonFlags } from '../../commandUtils/flags';
 import { getPaginatedQueryOptions } from '../../commandUtils/pagination';
 import fetch from '../../fetch';
@@ -31,7 +31,6 @@ import { getExpoConfig } from '../../project/expoConfig';
 import {
   findProjectRootAsync,
   getOwnerAccountForProjectIdAsync,
-  getProjectIdAsync,
   installExpoUpdatesAsync,
   isExpoUpdatesInstalledOrAvailable,
 } from '../../project/projectUtils';
@@ -169,6 +168,10 @@ export default class UpdatePublish extends EasCommand {
     ...EasNonInteractiveAndJsonFlags,
   };
 
+  static override contextDefinition = {
+    ...EASCommandProjectIdContext,
+  };
+
   async runAsync(): Promise<void> {
     const { flags } = await this.parse(UpdatePublish);
     const paginatedQueryOptions = getPaginatedQueryOptions(flags);
@@ -185,6 +188,9 @@ export default class UpdatePublish extends EasCommand {
       'non-interactive': nonInteractive,
       json: jsonFlag,
     } = flags;
+    const { projectId } = await this.getContextAsync(UpdatePublish, {
+      nonInteractive,
+    });
 
     if (jsonFlag) {
       enableJsonOutput();
@@ -234,7 +240,6 @@ export default class UpdatePublish extends EasCommand {
     }
 
     const runtimeVersions = await getRuntimeVersionObjectAsync(exp, platformFlag, projectDir);
-    const projectId = await getProjectIdAsync(exp, { nonInteractive });
     await checkEASUpdateURLIsSetAsync(exp, projectId);
 
     if (!branchName) {

packages/eas-cli/src/commands/update/list.ts

@@ -1,15 +1,13 @@
 import { Flags } from '@oclif/core';
 
 import { selectBranchOnAppAsync } from '../../branch/queries';
-import EasCommand from '../../commandUtils/EasCommand';
+import EasCommand, { EASCommandProjectIdContext } from '../../commandUtils/EasCommand';
 import { EasNonInteractiveAndJsonFlags } from '../../commandUtils/flags';
 import {
   EasPaginatedQueryFlags,
   getLimitFlagWithCustomValues,
   getPaginatedQueryOptions,
 } from '../../commandUtils/pagination';
-import { getExpoConfig } from '../../project/expoConfig';
-import { findProjectRootAsync, getProjectIdAsync } from '../../project/projectUtils';
 import {
   listAndRenderUpdateGroupsOnAppAsync,
   listAndRenderUpdateGroupsOnBranchAsync,
@@ -34,19 +32,22 @@ export default class UpdateList extends EasCommand {
     ...EasNonInteractiveAndJsonFlags,
   };
 
+  static override contextDefinition = {
+    ...EASCommandProjectIdContext,
+  };
+
   async runAsync(): Promise<void> {
     const { flags } = await this.parse(UpdateList);
     const { branch: branchFlag, all, json: jsonFlag, 'non-interactive': nonInteractive } = flags;
+    const { projectId } = await this.getContextAsync(UpdateList, {
+      nonInteractive,
+    });
     const paginatedQueryOptions = getPaginatedQueryOptions(flags);
 
     if (jsonFlag) {
       enableJsonOutput();
     }
 
-    const projectDir = await findProjectRootAsync();
-    const exp = getExpoConfig(projectDir);
-    const projectId = await getProjectIdAsync(exp, { nonInteractive });
-
     if (all) {
       listAndRenderUpdateGroupsOnAppAsync({ projectId, paginatedQueryOptions });
     } else {

packages/eas-cli/src/commands/webhook/create.ts

@@ -1,12 +1,10 @@
 import { Flags } from '@oclif/core';
 
-import EasCommand from '../../commandUtils/EasCommand';
+import EasCommand, { EASCommandProjectIdContext } from '../../commandUtils/EasCommand';
 import { EASNonInteractiveFlag } from '../../commandUtils/flags';
 import { WebhookType } from '../../graphql/generated';
 import { WebhookMutation } from '../../graphql/mutations/WebhookMutation';
 import { ora } from '../../ora';
-import { getExpoConfig } from '../../project/expoConfig';
-import { findProjectRootAsync, getProjectIdAsync } from '../../project/projectUtils';
 import { prepareInputParamsAsync } from '../../webhooks/input';
 
 export default class WebhookCreate extends EasCommand {
@@ -27,15 +25,17 @@ export default class WebhookCreate extends EasCommand {
     ...EASNonInteractiveFlag,
   };
 
+  static override contextDefinition = {
+    ...EASCommandProjectIdContext,
+  };
+
   async runAsync(): Promise<void> {
     const { flags } = await this.parse(WebhookCreate);
+    const { projectId } = await this.getContextAsync(WebhookCreate, {
+      nonInteractive: flags['non-interactive'],
+    });
     const webhookInputParams = await prepareInputParamsAsync(flags);
 
-    const projectDir = await findProjectRootAsync();
-    const exp = getExpoConfig(projectDir);
-
-    const projectId = await getProjectIdAsync(exp, { nonInteractive: flags['non-interactive'] });
-
     const spinner = ora('Creating a webhook').start();
     try {
       await WebhookMutation.createWebhookAsync(projectId, webhookInputParams);

packages/eas-cli/src/commands/webhook/delete.ts

@@ -2,15 +2,13 @@ import assert from 'assert';
 import chalk from 'chalk';
 import nullthrows from 'nullthrows';
 
-import EasCommand from '../../commandUtils/EasCommand';
+import EasCommand, { EASCommandProjectIdContext } from '../../commandUtils/EasCommand';
 import { EASNonInteractiveFlag } from '../../commandUtils/flags';
 import { WebhookFragment } from '../../graphql/generated';
 import { WebhookMutation } from '../../graphql/mutations/WebhookMutation';
 import { WebhookQuery } from '../../graphql/queries/WebhookQuery';
 import Log from '../../log';
 import { ora } from '../../ora';
-import { getExpoConfig } from '../../project/expoConfig';
-import { findProjectRootAsync, getProjectIdAsync } from '../../project/projectUtils';
 import { promptAsync, toggleConfirmAsync } from '../../prompts';
 import { formatWebhook } from '../../webhooks/formatWebhook';
 
@@ -29,15 +27,18 @@ export default class WebhookDelete extends EasCommand {
     ...EASNonInteractiveFlag,
   };
 
+  static override contextDefinition = {
+    ...EASCommandProjectIdContext,
+  };
+
   async runAsync(): Promise<void> {
     let {
       args: { ID: webhookId },
       flags: { 'non-interactive': nonInteractive },
     } = await this.parse(WebhookDelete);
-
+    const { projectId } = await this.getContextAsync(WebhookDelete, {
-    const projectDir = await findProjectRootAsync();
+      nonInteractive,
-    const exp = getExpoConfig(projectDir);
+    });
-    const projectId = await getProjectIdAsync(exp, { nonInteractive });
 
     let webhook: WebhookFragment | undefined =
       webhookId && (await WebhookQuery.byIdAsync(webhookId));

packages/eas-cli/src/commands/webhook/list.ts

@@ -1,17 +1,12 @@
 import { Flags } from '@oclif/core';
 import chalk from 'chalk';
 
-import EasCommand from '../../commandUtils/EasCommand';
+import EasCommand, { EASCommandProjectIdContext } from '../../commandUtils/EasCommand';
 import { WebhookType } from '../../graphql/generated';
 import { WebhookQuery } from '../../graphql/queries/WebhookQuery';
 import Log from '../../log';
 import { ora } from '../../ora';
-import { getExpoConfig } from '../../project/expoConfig';
+import { getDisplayNameForProjectIdAsync } from '../../project/projectUtils';
-import {
-  findProjectRootAsync,
-  getDisplayNameForProjectIdAsync,
-  getProjectIdAsync,
-} from '../../project/projectUtils';
 import { formatWebhook } from '../../webhooks/formatWebhook';
 
 export default class WebhookList extends EasCommand {
@@ -24,16 +19,18 @@ export default class WebhookList extends EasCommand {
     }),
   };
 
+  static override contextDefinition = {
+    ...EASCommandProjectIdContext,
+  };
+
   async runAsync(): Promise<void> {
     const {
       flags: { event },
     } = await this.parse(WebhookList);
+    const { projectId } = await this.getContextAsync(WebhookList, {
+      nonInteractive: true,
+    });
 
-    const projectDir = await findProjectRootAsync();
-    const exp = getExpoConfig(projectDir);
-
-    // this command is non-interactive by design
-    const projectId = await getProjectIdAsync(exp, { nonInteractive: true });
     const projectDisplayName = await getDisplayNameForProjectIdAsync(projectId);
 
     const spinner = ora(`Fetching the list of webhook on project ${projectDisplayName}`).start();

packages/eas-cli/src/credentials/android/actions/BuildCredentialsUtils.ts

@@ -8,7 +8,6 @@ import { GradleBuildContext } from '../../../project/android/gradle';
 import {
   getOwnerAccountForProjectIdAsync,
   getProjectConfigDescription,
-  getProjectIdAsync,
 } from '../../../project/projectUtils';
 import { promptAsync } from '../../../prompts';
 import { CredentialsContext } from '../../context';
@@ -91,9 +90,8 @@ export async function getAppLookupParamsFromContextAsync(
   ctx: CredentialsContext,
   gradleContext?: GradleBuildContext
 ): Promise<AppLookupParams> {
-  ctx.ensureProjectContext();
   const projectName = ctx.exp.slug;
-  const projectId = await getProjectIdAsync(ctx.exp, { nonInteractive: ctx.nonInteractive });
+  const projectId = ctx.projectId;
   const account = await getOwnerAccountForProjectIdAsync(projectId);
 
   const androidApplicationIdentifier = await getApplicationIdAsync(

packages/eas-cli/src/credentials/android/actions/CreateKeystore.ts

@@ -1,6 +1,5 @@
 import { AccountFragment, AndroidKeystoreFragment } from '../../../graphql/generated';
 import Log from '../../../log';
-import { getProjectIdAsync } from '../../../project/projectUtils';
 import { CredentialsContext } from '../../context';
 import { askForUserProvidedAsync } from '../../utils/promptForCredentials';
 import { KeystoreWithType, keystoreSchema } from '../credentials';
@@ -15,7 +14,7 @@ export class CreateKeystore {
       throw new Error(`New keystore cannot be created in non-interactive mode.`);
     }
 
-    const projectId = await getProjectIdAsync(ctx.exp, { nonInteractive: ctx.nonInteractive });
+    const projectId = ctx.projectId;
     const keystore = await this.provideOrGenerateAsync(projectId);
     const keystoreFragment = await ctx.android.createKeystoreAsync(this.account, keystore);
     Log.succeed('Created keystore');

packages/eas-cli/src/credentials/context.ts

@@ -4,7 +4,6 @@ import { EasJson } from '@expo/eas-json';
 import chalk from 'chalk';
 
 import Log from '../log';
-import { getExpoConfig } from '../project/expoConfig';
 import { confirmAsync } from '../prompts';
 import { Actor } from '../user/User';
 import * as AndroidGraphqlClient from './android/api/GraphqlClient';
@@ -12,6 +11,11 @@ import * as IosGraphqlClient from './ios/api/GraphqlClient';
 import AppStoreApi from './ios/appstore/AppStoreApi';
 import { AuthenticationMode } from './ios/appstore/authenticateTypes';
 
+export type CredentialsContextProjectInfo = {
+  exp: ExpoConfig;
+  projectId: string;
+};
+
 export class CredentialsContext {
   public readonly android = AndroidGraphqlClient;
   public readonly appStore = new AppStoreApi();
@@ -22,58 +26,30 @@ export class CredentialsContext {
   public readonly easJsonCliConfig?: EasJson['cli'];
 
   private shouldAskAuthenticateAppStore: boolean = true;
-  private resolvedExp?: ExpoConfig;
 
-  constructor(
+  private projectInfo: CredentialsContextProjectInfo;
-    private options: {
+
-      exp?: ExpoConfig;
+  constructor(options: {
+    projectInfo: CredentialsContextProjectInfo;
     easJsonCliConfig?: EasJson['cli'];
     nonInteractive: boolean;
     projectDir: string;
     user: Actor;
     env?: Env;
-    }
+  }) {
-  ) {
     this.easJsonCliConfig = options.easJsonCliConfig;
     this.projectDir = options.projectDir;
     this.user = options.user;
     this.nonInteractive = options.nonInteractive ?? false;
-
+    this.projectInfo = options.projectInfo;
-    this.resolvedExp = options.exp;
-    if (!this.resolvedExp) {
-      this.resolvedExp =
-        CredentialsContext.getExpoConfigInProject(this.projectDir, { env: options.env }) ??
-        undefined;
-    }
-  }
-
-  static getExpoConfigInProject(
-    projectDir: string,
-    { env }: { env?: Env } = {}
-  ): ExpoConfig | null {
-    try {
-      return getExpoConfig(projectDir, { env });
-    } catch {
-      // ignore error, context might be created outside of expo project
-      return null;
-    }
-  }
-
-  get hasProjectContext(): boolean {
-    return !!this.resolvedExp;
   }
 
   get exp(): ExpoConfig {
-    this.ensureProjectContext();
+    return this.projectInfo!.exp;
-    return this.resolvedExp!;
   }
 
-  public ensureProjectContext(): void {
+  get projectId(): string {
-    if (this.hasProjectContext) {
+    return this.projectInfo!.projectId;
-      return;
-    }
-    // trigger getConfig error
-    getExpoConfig(this.options.projectDir);
   }
 
   async bestEffortAppStoreAuthenticateAsync(): Promise<void> {

packages/eas-cli/src/credentials/ios/actions/BuildCredentialsUtils.ts

@@ -7,7 +7,7 @@ import {
   IosDistributionType as GraphQLIosDistributionType,
   IosAppBuildCredentialsFragment,
 } from '../../../graphql/generated';
-import { getOwnerAccountForProjectIdAsync, getProjectIdAsync } from '../../../project/projectUtils';
+import { getOwnerAccountForProjectIdAsync } from '../../../project/projectUtils';
 import { CredentialsContext } from '../../context';
 import { AppLookupParams } from '../api/graphql/types/AppLookupParams';
 import { App, Target } from '../types';
@@ -82,9 +82,8 @@ export async function assignBuildCredentialsAsync(
 }
 
 export async function getAppFromContextAsync(ctx: CredentialsContext): Promise<App> {
-  ctx.ensureProjectContext();
   const projectName = ctx.exp.slug;
-  const projectId = await getProjectIdAsync(ctx.exp, { nonInteractive: ctx.nonInteractive });
+  const projectId = ctx.projectId;
   const account = await getOwnerAccountForProjectIdAsync(projectId);
   return {
     account,

packages/eas-cli/src/credentials/manager/HelperActions.ts

@@ -1,8 +1,11 @@
 import Log from '../../log';
 import { pressAnyKeyToContinueAsync } from '../../prompts';
-import { CredentialsContext } from '../context';
+import { Actor } from '../../user/User';
+import { CredentialsContext, CredentialsContextProjectInfo } from '../context';
 
 export interface Action<T = void> {
+  actor: Actor;
+  projectInfo: CredentialsContextProjectInfo;
   runAsync(ctx: CredentialsContext): Promise<T>;
 }
 

packages/eas-cli/src/credentials/manager/IosActions.ts

@@ -1,4 +1,3 @@
-import { CredentialsContext } from '../context';
 import { ActionInfo, IosActionType, Scope } from './Actions';
 
 export const highLevelActions: ActionInfo[] = [
@@ -47,7 +46,7 @@ export const credentialsJsonActions: ActionInfo[] = [
   },
 ];
 
-export function getPushKeyActions(ctx: CredentialsContext): ActionInfo[] {
+export function getPushKeyActions(): ActionInfo[] {
   return [
     {
       value: IosActionType.SetUpPushKey,
@@ -57,7 +56,7 @@ export function getPushKeyActions(ctx: CredentialsContext): ActionInfo[] {
     {
       value: IosActionType.CreatePushKey,
       title: 'Add a new push key',
-      scope: ctx.hasProjectContext ? Scope.Project : Scope.Account,
+      scope: Scope.Project,
     },
     {
       value: IosActionType.UseExistingPushKey,
@@ -77,7 +76,7 @@ export function getPushKeyActions(ctx: CredentialsContext): ActionInfo[] {
   ];
 }
 
-export function getAscApiKeyActions(ctx: CredentialsContext): ActionInfo[] {
+export function getAscApiKeyActions(): ActionInfo[] {
   return [
     {
       value: IosActionType.SetUpAscApiKeyForSubmissions,
@@ -92,7 +91,7 @@ export function getAscApiKeyActions(ctx: CredentialsContext): ActionInfo[] {
     {
       value: IosActionType.CreateAscApiKeyForSubmissions,
       title: 'Add a new API Key For EAS Submit',
-      scope: ctx.hasProjectContext ? Scope.Project : Scope.Account,
+      scope: Scope.Project,
     },
     {
       value: IosActionType.RemoveAscApiKey,
@@ -107,7 +106,7 @@ export function getAscApiKeyActions(ctx: CredentialsContext): ActionInfo[] {
   ];
 }
 
-export function getBuildCredentialsActions(ctx: CredentialsContext): ActionInfo[] {
+export function getBuildCredentialsActions(): ActionInfo[] {
   return [
     {
       // This command will be triggered during build to ensure all credentials are ready
@@ -124,7 +123,7 @@ export function getBuildCredentialsActions(ctx: CredentialsContext): ActionInfo[
     {
       value: IosActionType.CreateDistributionCertificate,
       title: `Distribution Certificate: Add a new one to your account`,
-      scope: ctx.hasProjectContext ? Scope.Project : Scope.Account,
+      scope: Scope.Project,
     },
     {
       value: IosActionType.RemoveDistributionCertificate,

packages/eas-cli/src/credentials/manager/ManageAndroid.ts

@@ -4,9 +4,7 @@ import assert from 'assert';
 
 import Log, { learnMore } from '../../log';
 import { GradleBuildContext, resolveGradleBuildContextAsync } from '../../project/android/gradle';
-import { getProjectIdAsync } from '../../project/projectUtils';
 import { promptAsync } from '../../prompts';
-import { ensureLoggedInAsync } from '../../user/actions';
 import { AssignFcm } from '../android/actions/AssignFcm';
 import { AssignGoogleServiceAccountKey } from '../android/actions/AssignGoogleServiceAccountKey';
 import {
@@ -50,27 +48,23 @@ export class ManageAndroid {
   constructor(private callingAction: Action, private projectDir: string) {}
 
   async runAsync(currentActions: ActionInfo[] = highLevelActions): Promise<void> {
-    const hasProjectContext = !!CredentialsContext.getExpoConfigInProject(this.projectDir);
+    const hasProjectContext = !!this.callingAction.projectInfo;
     const buildProfile = hasProjectContext
       ? await new SelectBuildProfileFromEasJson(this.projectDir, Platform.ANDROID).runAsync()
       : null;
     const ctx = new CredentialsContext({
       projectDir: process.cwd(),
-      // this command is interactive by design
+      projectInfo: this.callingAction.projectInfo,
-      user: await ensureLoggedInAsync({ nonInteractive: false }),
+      user: this.callingAction.actor,
       env: buildProfile?.env,
       nonInteractive: false,
     });
 
-    let gradleContext;
-    if (ctx.hasProjectContext) {
     assert(buildProfile, 'buildProfile must be defined in a project context');
-      gradleContext = await this.createProjectContextAsync(ctx, buildProfile);
+    const gradleContext = await this.createProjectContextAsync(ctx, buildProfile);
-    }
 
     while (true) {
       try {
-        if (ctx.hasProjectContext) {
         const appLookupParams = await getAppLookupParamsFromContextAsync(ctx, gradleContext);
         const appCredentials = await ctx.android.getAndroidAppCredentialsWithCommonFieldsAsync(
           appLookupParams
@@ -82,14 +76,11 @@ export class ManageAndroid {
         }
 
         // copy legacy credentials if user is new to EAS and has legacy credentials
-          const canCopyLegacyCredentials = await canCopyLegacyCredentialsAsync(
+        const canCopyLegacyCredentials = await canCopyLegacyCredentialsAsync(ctx, appLookupParams);
-            ctx,
-            appLookupParams
-          );
         if (canCopyLegacyCredentials) {
           await promptUserAndCopyLegacyCredentialsAsync(ctx, appLookupParams);
         }
-        }
+
         const { action: chosenAction } = await promptAsync({
           type: 'select',
           name: 'action',
@@ -140,11 +131,6 @@ export class ManageAndroid {
     ctx: CredentialsContext,
     buildProfile: BuildProfile<Platform.ANDROID>
   ): Promise<GradleBuildContext | undefined> {
-    assert(ctx.hasProjectContext, 'createProjectContextAsync: must have project context.');
-
-    // ensure the project exists on the EAS server
-    await getProjectIdAsync(ctx.exp, { nonInteractive: ctx.nonInteractive });
-
     return await resolveGradleBuildContextAsync(ctx.projectDir, buildProfile);
   }
 
@@ -153,10 +139,6 @@ export class ManageAndroid {
     action: AndroidActionType,
     gradleContext?: GradleBuildContext
   ): Promise<void> {
-    assert(
-      ctx.hasProjectContext,
-      'You must be in your project directory in order to perform this action'
-    );
     const appLookupParams = await getAppLookupParamsFromContextAsync(ctx, gradleContext);
     if (action === AndroidActionType.CreateKeystore) {
       const selectBuildCredentialsResult = await new SelectAndroidBuildCredentials(

packages/eas-cli/src/credentials/manager/ManageIos.ts

@@ -12,9 +12,8 @@ import {
 import Log, { learnMore } from '../../log';
 import { resolveXcodeBuildContextAsync } from '../../project/ios/scheme';
 import { resolveTargetsAsync } from '../../project/ios/target';
-import { getOwnerAccountForProjectIdAsync, getProjectIdAsync } from '../../project/projectUtils';
+import { getOwnerAccountForProjectIdAsync } from '../../project/projectUtils';
 import { confirmAsync, promptAsync, selectAsync } from '../../prompts';
-import { ensureActorHasPrimaryAccount, ensureLoggedInAsync } from '../../user/actions';
 import { CredentialsContext } from '../context';
 import {
   AppStoreApiKeyPurpose,
@@ -58,44 +57,33 @@ export class ManageIos {
   constructor(private callingAction: Action, private projectDir: string) {}
 
   async runAsync(currentActions: ActionInfo[] = highLevelActions): Promise<void> {
-    const hasProjectContext = !!CredentialsContext.getExpoConfigInProject(this.projectDir);
+    const buildProfile = this.callingAction.projectInfo
-    const buildProfile = hasProjectContext
       ? await new SelectBuildProfileFromEasJson(this.projectDir, Platform.IOS).runAsync()
       : null;
     const ctx = new CredentialsContext({
       projectDir: process.cwd(),
-      // this command is interactive by design
+      projectInfo: this.callingAction.projectInfo,
-      user: await ensureLoggedInAsync({ nonInteractive: false }),
+      user: this.callingAction.actor,
       env: buildProfile?.env,
       nonInteractive: false,
     });
-    const buildCredentialsActions = getBuildCredentialsActions(ctx);
+    const buildCredentialsActions = getBuildCredentialsActions();
-    const pushKeyActions = getPushKeyActions(ctx);
+    const pushKeyActions = getPushKeyActions();
-    const ascApiKeyActions = getAscApiKeyActions(ctx);
+    const ascApiKeyActions = getAscApiKeyActions();
 
     await ctx.bestEffortAppStoreAuthenticateAsync();
 
-    const getAccountForProjectAsync = async (): Promise<AccountFragment> => {
+    const account = await getOwnerAccountForProjectIdAsync(
-      const projectId = await getProjectIdAsync(ctx.exp, { nonInteractive: false });
+      this.callingAction.projectInfo.projectId
-      return await getOwnerAccountForProjectIdAsync(projectId);
+    );
-    };
 
-    const account = ctx.hasProjectContext
-      ? await getAccountForProjectAsync()
-      : ensureActorHasPrimaryAccount(ctx.user);
-
-    let app = null;
-    let targets = null;
-    if (ctx.hasProjectContext) {
     assert(buildProfile, 'buildProfile must be defined in project context');
     const projectContext = await this.createProjectContextAsync(ctx, account, buildProfile);
-      app = projectContext.app;
+    const app = projectContext.app;
-      targets = projectContext.targets;
+    const targets = projectContext.targets;
-    }
 
     while (true) {
       try {
-        if (ctx.hasProjectContext) {
         assert(targets && app);
         const iosAppCredentialsMap: IosAppCredentialsMap = {};
         for (const target of targets) {
@@ -104,7 +92,6 @@ export class ManageIos {
             await ctx.ios.getIosAppCredentialsWithCommonFieldsAsync(appLookupParams);
         }
         displayIosCredentials(app, iosAppCredentialsMap, targets);
-        }
 
         const { action: chosenAction } = await promptAsync({
           type: 'select',
@@ -139,10 +126,6 @@ export class ManageIos {
             return await this.callingAction.runAsync(ctx);
           }
         } else if (actionInfo.scope === Scope.Project) {
-          assert(
-            ctx.hasProjectContext,
-            'You must be in your project directory in order to perform this action'
-          );
           await this.runProjectSpecificActionAsync(
             ctx,
             nullthrows(app, 'app must be defined in project context'),
@@ -174,11 +157,6 @@ export class ManageIos {
     app: App;
     targets: Target[];
   }> {
-    assert(ctx.hasProjectContext, 'createProjectContextAsync: must have project context.');
-
-    // ensure the project exists on the EAS server
-    await getProjectIdAsync(ctx.exp, { nonInteractive: ctx.nonInteractive });
-
     const app = { account, projectName: ctx.exp.slug };
     const xcodeBuildContext = await resolveXcodeBuildContextAsync(
       {

packages/eas-cli/src/credentials/manager/SelectPlatform.ts

@@ -1,16 +1,22 @@
 import { selectPlatformAsync } from '../../platform';
+import { Actor } from '../../user/User';
+import { CredentialsContextProjectInfo } from '../context';
 import { ManageAndroid } from './ManageAndroid';
 import { ManageIos } from './ManageIos';
 
 export class SelectPlatform {
-  constructor(private readonly flagPlatform?: string) {}
+  constructor(
+    public readonly actor: Actor,
+    public readonly projectInfo: CredentialsContextProjectInfo,
+    private readonly flagPlatform?: string
+  ) {}
 
   async runAsync(): Promise<void> {
     const platform = await selectPlatformAsync(this.flagPlatform);
 
     if (platform === 'ios') {
-      return await new ManageIos(new SelectPlatform(platform), process.cwd()).runAsync();
+      return await new ManageIos(this, process.cwd()).runAsync();
     }
-    return await new ManageAndroid(new SelectPlatform(platform), process.cwd()).runAsync();
+    return await new ManageAndroid(this, process.cwd()).runAsync();
   }
 }

packages/eas-cli/src/devices/__tests__/manager-test.ts

@@ -44,16 +44,6 @@ describe(AccountResolver, () => {
     };
 
     describe('when inside project dir', () => {
-      const exp = {
-        name: 'wat',
-        slug: 'wat',
-        extra: {
-          eas: {
-            projectId: '1234',
-          },
-        },
-      };
-
       beforeEach(() => {
         jest.mocked(AppQuery.byIdAsync).mockResolvedValue({
           id: 'test-project-id',
@@ -72,7 +62,7 @@ describe(AccountResolver, () => {
           value: true,
         }));
 
-        const resolver = new AccountResolver(exp, user);
+        const resolver = new AccountResolver('1234', user);
         const account = await resolver.resolveAccountAsync();
         expect(account).toEqual({
           id: user.accounts[1].id,
@@ -89,19 +79,7 @@ describe(AccountResolver, () => {
           account: user.accounts[0],
         }));
 
-        const resolver = new AccountResolver(exp, user);
+        const resolver = new AccountResolver('1234', user);
-        const account = await resolver.resolveAccountAsync();
-        expect(account).toEqual(user.accounts[0]);
-      });
-    });
-
-    describe('when outside project dir', () => {
-      it('asks the user to choose the account from his account list', async () => {
-        jest.mocked(prompts).mockImplementationOnce(async () => ({
-          account: user.accounts[0],
-        }));
-
-        const resolver = new AccountResolver(null, user);
         const account = await resolver.resolveAccountAsync();
         expect(account).toEqual(user.accounts[0]);
       });

packages/eas-cli/src/devices/context.ts

@@ -1,35 +1,24 @@
-import { ExpoConfig, getConfig } from '@expo/config';
-
 import AppStoreApi from '../credentials/ios/appstore/AppStoreApi';
-import { findProjectRootAsync } from '../project/projectUtils';
 import { Actor } from '../user/User';
 
 export interface DeviceManagerContext {
   appStore: AppStoreApi;
-  exp: ExpoConfig | null;
-  projectDir: string | null;
   user: Actor;
+  projectId: string;
 }
 
 export async function createContextAsync({
   appStore,
-  cwd,
   user,
+  projectId,
 }: {
   appStore: AppStoreApi;
-  cwd?: string;
   user: Actor;
+  projectId: string;
 }): Promise<DeviceManagerContext> {
-  const projectDir = await findProjectRootAsync({ cwd });
-  let exp: ExpoConfig | null = null;
-  if (projectDir) {
-    const config = getConfig(projectDir, { skipSDKVersionRequirement: true });
-    exp = config.exp;
-  }
   return {
     appStore,
-    projectDir,
-    exp,
     user,
+    projectId,
   };
 }

packages/eas-cli/src/devices/manager.ts

@@ -1,4 +1,3 @@
-import { ExpoConfig } from '@expo/config';
 import assert from 'assert';
 import chalk from 'chalk';
 
@@ -6,7 +5,7 @@ import { AppleTeamMutation } from '../credentials/ios/api/graphql/mutations/Appl
 import { AppleTeamQuery } from '../credentials/ios/api/graphql/queries/AppleTeamQuery';
 import { AccountFragment, AppleTeamFragment } from '../graphql/generated';
 import Log from '../log';
-import { getOwnerAccountForProjectIdAsync, getProjectIdAsync } from '../project/projectUtils';
+import { getOwnerAccountForProjectIdAsync } from '../project/projectUtils';
 import { Choice, confirmAsync, promptAsync } from '../prompts';
 import { Actor } from '../user/User';
 import DeviceCreateAction from './actions/create/action';
@@ -38,30 +37,25 @@ export default class DeviceManager {
   }
 
   private async resolveAccountAsync(): Promise<AccountFragment> {
-    const resolver = new AccountResolver(this.ctx.exp, this.ctx.user);
+    const resolver = new AccountResolver(this.ctx.projectId, this.ctx.user);
     return await resolver.resolveAccountAsync();
   }
 }
 
 export class AccountResolver {
-  constructor(private exp: ExpoConfig | null, private user: Actor) {}
+  constructor(private projectId: string | null, private user: Actor) {}
 
   public async resolveAccountAsync(): Promise<AccountFragment> {
-    if (this.exp) {
     const account = await this.resolveProjectAccountAsync();
     if (account) {
       return account;
     }
-    }
     return await this.promptForAccountAsync();
   }
 
   private async resolveProjectAccountAsync(): Promise<AccountFragment | undefined> {
-    assert(this.exp, 'expo config is not set');
+    assert(this.projectId, 'expo config is not set');
-
+    const account = await getOwnerAccountForProjectIdAsync(this.projectId);
-    // this command is interactive by design
-    const projectId = await getProjectIdAsync(this.exp, { nonInteractive: false });
-    const account = await getOwnerAccountForProjectIdAsync(projectId);
 
     const useProjectAccount = await confirmAsync({
       message: `You're inside the project directory. Would you like to use the ${chalk.underline(

packages/eas-cli/src/metadata/context.ts

@@ -9,7 +9,6 @@ import { getRequestContext } from '../credentials/ios/appstore/authenticate';
 import { getExpoConfig } from '../project/expoConfig';
 import { getBundleIdentifierAsync } from '../project/ios/bundleIdentifier';
 import { Actor } from '../user/User';
-import { ensureLoggedInAsync } from '../user/actions';
 
 export type MetadataContext = {
   /** Submission profile platform to use */
@@ -55,7 +54,7 @@ export async function createMetadataContextAsync(params: {
   );
 
   const exp = params.exp ?? getExpoConfig(params.projectDir);
-  const user = await ensureLoggedInAsync({ nonInteractive: params.credentialsCtx.nonInteractive });
+  const user = params.credentialsCtx.user;
   const bundleIdentifier =
     submitProfile.bundleIdentifier ?? (await getBundleIdentifierAsync(params.projectDir, exp));
 

packages/eas-cli/src/project/__tests__/fetchOrCreateProjectIDForWriteToConfigWithConfirmationAsync-test.ts

@@ -1,3 +1,4 @@
+import { jester } from '../../credentials/__tests__/fixtures-constants';
 import { fetchOrCreateProjectIDForWriteToConfigWithConfirmationAsync } from '../fetchOrCreateProjectIDForWriteToConfigWithConfirmationAsync';
 
 describe(fetchOrCreateProjectIDForWriteToConfigWithConfirmationAsync, () => {
@@ -5,7 +6,8 @@ describe(fetchOrCreateProjectIDForWriteToConfigWithConfirmationAsync, () => {
     await expect(
       fetchOrCreateProjectIDForWriteToConfigWithConfirmationAsync(
         { accountName: 'fake', projectName: 'fake' },
-        { nonInteractive: true }
+        { nonInteractive: true },
+        jester
       )
     ).rejects.toThrow(
       `Must configure EAS project by running 'eas init' before this command can be run in non-interactive mode.`

packages/eas-cli/src/project/android/__tests__/applicationId-test.ts

@@ -110,7 +110,7 @@ describe(ensureApplicationIdIsDefinedForManagedProjectAsync, () => {
         '/app'
       );
       await expect(
-        ensureApplicationIdIsDefinedForManagedProjectAsync('/app', {} as any)
+        ensureApplicationIdIsDefinedForManagedProjectAsync('/app', {} as any, mockJester)
       ).rejects.toThrowError(/we can't update this file programmatically/);
     });
     it('prompts for the Android package if using app.json', async () => {
@@ -126,7 +126,7 @@ describe(ensureApplicationIdIsDefinedForManagedProjectAsync, () => {
       }));
 
       await expect(
-        ensureApplicationIdIsDefinedForManagedProjectAsync('/app', {} as any)
+        ensureApplicationIdIsDefinedForManagedProjectAsync('/app', {} as any, mockJester)
       ).resolves.toBe('com.expo.notdominik');
       expect(promptAsync).toHaveBeenCalled();
     });
@@ -143,7 +143,7 @@ describe(ensureApplicationIdIsDefinedForManagedProjectAsync, () => {
       }));
 
       await expect(
-        ensureApplicationIdIsDefinedForManagedProjectAsync('/app', {} as any)
+        ensureApplicationIdIsDefinedForManagedProjectAsync('/app', {} as any, mockJester)
       ).resolves.toBe('com.expo.notdominik');
       const appJson = JSON.parse(await fs.readFile('/app/app.json', 'utf-8'));
       expect(appJson).toMatchObject({

packages/eas-cli/src/project/android/applicationId.ts

@@ -11,7 +11,7 @@ import env from '../../env';
 import Log, { learnMore } from '../../log';
 import { getProjectConfigDescription, getUsername } from '../../project/projectUtils';
 import { promptAsync } from '../../prompts';
-import { ensureLoggedInAsync } from '../../user/actions';
+import { Actor } from '../../user/User';
 import { resolveWorkflowAsync } from '../workflow';
 import { GradleBuildContext } from './gradle';
 import * as gradleUtils from './gradleUtils';
@@ -20,7 +20,8 @@ export const INVALID_APPLICATION_ID_MESSAGE = `Invalid format of Android applica
 
 export async function ensureApplicationIdIsDefinedForManagedProjectAsync(
   projectDir: string,
-  exp: ExpoConfig
+  exp: ExpoConfig,
+  actor: Actor
 ): Promise<string> {
   const workflow = await resolveWorkflowAsync(projectDir, Platform.ANDROID);
   assert(workflow === Workflow.MANAGED, 'This function should be called only for managed projects');
@@ -30,7 +31,7 @@ export async function ensureApplicationIdIsDefinedForManagedProjectAsync(
       moduleName: gradleUtils.DEFAULT_MODULE_NAME,
     });
   } catch {
-    return await configureApplicationIdAsync(projectDir, exp);
+    return await configureApplicationIdAsync(projectDir, exp, actor);
   }
 }
 
@@ -109,7 +110,11 @@ export async function getApplicationIdAsync(
   }
 }
 
-async function configureApplicationIdAsync(projectDir: string, exp: ExpoConfig): Promise<string> {
+async function configureApplicationIdAsync(
+  projectDir: string,
+  exp: ExpoConfig,
+  actor: Actor
+): Promise<string> {
   const paths = getConfigFilePaths(projectDir);
   // we can't automatically update app.config.js
   if (paths.dynamicConfigPath) {
@@ -127,7 +132,7 @@ async function configureApplicationIdAsync(projectDir: string, exp: ExpoConfig):
     )}`
   );
 
-  const suggestedAndroidApplicationId = await getSuggestedApplicationIdAsync(exp);
+  const suggestedAndroidApplicationId = await getSuggestedApplicationIdAsync(exp, actor);
   const { packageName } = await promptAsync({
     name: 'packageName',
     type: 'text',
@@ -168,14 +173,17 @@ export function warnIfAndroidPackageDefinedInAppConfigForBareWorkflowProject(
   }
 }
 
-async function getSuggestedApplicationIdAsync(exp: ExpoConfig): Promise<string | undefined> {
+async function getSuggestedApplicationIdAsync(
+  exp: ExpoConfig,
+  actor: Actor
+): Promise<string | undefined> {
   // Attempt to use the ios bundle id first since it's convenient to have them aligned.
   const maybeBundleId = IOSConfig.BundleIdentifier.getBundleIdentifier(exp);
   if (maybeBundleId && isApplicationIdValid(maybeBundleId)) {
     return maybeBundleId;
   } else {
     // the only callsite is heavily interactive
-    const username = getUsername(exp, await ensureLoggedInAsync({ nonInteractive: false }));
+    const username = getUsername(exp, actor);
     // It's common to use dashes in your node project name, strip them from the suggested package name.
     const possibleId = `com.${username}.${exp.slug}`.split('-').join('');
     if (isApplicationIdValid(possibleId)) {

packages/eas-cli/src/project/applicationIdentifier.ts

@@ -2,6 +2,7 @@ import { ExpoConfig } from '@expo/config';
 import { Platform, Workflow } from '@expo/eas-build-job';
 import { BuildProfile } from '@expo/eas-json';
 
+import { Actor } from '../user/User';
 import {
   ensureApplicationIdIsDefinedForManagedProjectAsync,
   getApplicationIdAsync,
@@ -16,7 +17,8 @@ export async function getApplicationIdentifierAsync(
   projectDir: string,
   exp: ExpoConfig,
   buildProfile: BuildProfile,
-  platform: Platform
+  platform: Platform,
+  actor: Actor
 ): Promise<string> {
   if (platform === Platform.ANDROID) {
     const profile = buildProfile as BuildProfile<Platform.ANDROID>;
@@ -24,7 +26,7 @@ export async function getApplicationIdentifierAsync(
     const gradleContext = await resolveGradleBuildContextAsync(projectDir, profile);
 
     if (workflow === Workflow.MANAGED) {
-      await ensureApplicationIdIsDefinedForManagedProjectAsync(projectDir, exp);
+      await ensureApplicationIdIsDefinedForManagedProjectAsync(projectDir, exp, actor);
     }
 
     return await getApplicationIdAsync(projectDir, exp, gradleContext);

packages/eas-cli/src/project/fetchOrCreateProjectIDForWriteToConfigWithConfirmationAsync.ts

@@ -7,7 +7,7 @@ import { AppMutation } from '../graphql/mutations/AppMutation';
 import { AppQuery } from '../graphql/queries/AppQuery';
 import { ora } from '../ora';
 import { confirmAsync } from '../prompts';
-import { ensureLoggedInAsync } from '../user/actions';
+import { Actor } from '../user/User';
 
 /**
  * 1. Looks for an existing project on EAS servers. If found, ask the user whether this is the
@@ -23,7 +23,8 @@ export async function fetchOrCreateProjectIDForWriteToConfigWithConfirmationAsyn
   },
   options: {
     nonInteractive: boolean;
-  }
+  },
+  actor: Actor
 ): Promise<string> {
   const { accountName, projectName } = projectInfo;
   const projectFullName = `@${accountName}/${projectName}`;
@@ -34,7 +35,6 @@ export async function fetchOrCreateProjectIDForWriteToConfigWithConfirmationAsyn
     );
   }
 
-  const actor = await ensureLoggedInAsync({ nonInteractive: options.nonInteractive });
   const allAccounts = actor.accounts;
   const accountNamesWhereUserHasSufficientPublishPermissions = new Set(
     allAccounts

packages/eas-cli/src/project/ios/__tests__/bundleIdentifier-test.ts

@@ -93,7 +93,7 @@ describe(ensureBundleIdentifierIsDefinedForManagedProjectAsync, () => {
         '/app'
       );
       await expect(
-        ensureBundleIdentifierIsDefinedForManagedProjectAsync('/app', {} as any)
+        ensureBundleIdentifierIsDefinedForManagedProjectAsync('/app', {} as any, mockJester)
       ).rejects.toThrowError(/we can't update this file programmatically/);
     });
     it('prompts for the bundle identifier if using app.json', async () => {
@@ -109,7 +109,7 @@ describe(ensureBundleIdentifierIsDefinedForManagedProjectAsync, () => {
       }));
 
       await expect(
-        ensureBundleIdentifierIsDefinedForManagedProjectAsync('/app', {} as any)
+        ensureBundleIdentifierIsDefinedForManagedProjectAsync('/app', {} as any, mockJester)
       ).resolves.toBe('com.expo.notdominik');
       expect(promptAsync).toHaveBeenCalled();
     });
@@ -126,7 +126,7 @@ describe(ensureBundleIdentifierIsDefinedForManagedProjectAsync, () => {
       }));
 
       await expect(
-        ensureBundleIdentifierIsDefinedForManagedProjectAsync('/app', {} as any)
+        ensureBundleIdentifierIsDefinedForManagedProjectAsync('/app', {} as any, mockJester)
       ).resolves.toBe('com.expo.notdominik');
       const appJson = JSON.parse(await fs.readFile('/app/app.json', 'utf-8'));
       expect(appJson).toMatchObject({

packages/eas-cli/src/project/ios/bundleIdentifier.ts

@@ -8,7 +8,7 @@ import fs from 'fs-extra';
 import { readAppJson } from '../../build/utils/appJson';
 import Log, { learnMore } from '../../log';
 import { promptAsync } from '../../prompts';
-import { ensureLoggedInAsync } from '../../user/actions';
+import { Actor } from '../../user/User';
 import { getProjectConfigDescription, getUsername } from '../projectUtils';
 import { resolveWorkflowAsync } from '../workflow';
 
@@ -16,7 +16,8 @@ export const INVALID_BUNDLE_IDENTIFIER_MESSAGE = `Invalid format of iOS bundle i
 
 export async function ensureBundleIdentifierIsDefinedForManagedProjectAsync(
   projectDir: string,
-  exp: ExpoConfig
+  exp: ExpoConfig,
+  actor: Actor
 ): Promise<string> {
   const workflow = await resolveWorkflowAsync(projectDir, Platform.IOS);
   assert(workflow === Workflow.MANAGED, 'This function should be called only for managed projects');
@@ -24,7 +25,7 @@ export async function ensureBundleIdentifierIsDefinedForManagedProjectAsync(
   try {
     return await getBundleIdentifierAsync(projectDir, exp);
   } catch {
-    return await configureBundleIdentifierAsync(projectDir, exp);
+    return await configureBundleIdentifierAsync(projectDir, exp, actor);
   }
 }
 
@@ -101,7 +102,8 @@ export async function getBundleIdentifierAsync(
 
 async function configureBundleIdentifierAsync(
   projectDir: string,
-  exp: ExpoConfig
+  exp: ExpoConfig,
+  actor: Actor
 ): Promise<string> {
   const paths = getConfigFilePaths(projectDir);
   // we can't automatically update app.config.js
@@ -120,7 +122,7 @@ async function configureBundleIdentifierAsync(
     )}`
   );
 
-  const suggestedBundleIdentifier = await getSuggestedBundleIdentifierAsync(exp);
+  const suggestedBundleIdentifier = await getSuggestedBundleIdentifierAsync(exp, actor);
   const { bundleIdentifier } = await promptAsync({
     name: 'bundleIdentifier',
     type: 'text',
@@ -166,14 +168,17 @@ export function isWildcardBundleIdentifier(bundleIdentifier: string): boolean {
   return wildcardRegex.test(bundleIdentifier);
 }
 
-async function getSuggestedBundleIdentifierAsync(exp: ExpoConfig): Promise<string | undefined> {
+async function getSuggestedBundleIdentifierAsync(
+  exp: ExpoConfig,
+  actor: Actor
+): Promise<string | undefined> {
   // Attempt to use the android package name first since it's convenient to have them aligned.
   const maybeAndroidPackage = AndroidConfig.Package.getPackage(exp);
   if (maybeAndroidPackage && isBundleIdentifierValid(maybeAndroidPackage)) {
     return maybeAndroidPackage;
   } else {
     // the only callsite is heavily interactive
-    const username = getUsername(exp, await ensureLoggedInAsync({ nonInteractive: false }));
+    const username = getUsername(exp, actor);
     // It's common to use dashes in your node project name, strip them from the suggested package name.
     const possibleId = `com.${username}.${exp.slug}`.split('-').join('');
     if (isBundleIdentifierValid(possibleId)) {

packages/eas-cli/src/project/projectUtils.ts

@@ -146,18 +146,17 @@ export async function getProjectIdAsync(
     }
   };
 
+  const actor = await ensureLoggedInAsync({ nonInteractive: options.nonInteractive });
   const projectId = await fetchOrCreateProjectIDForWriteToConfigWithConfirmationAsync(
     {
-      accountName: getAccountNameForEASProjectSync(
+      accountName: getAccountNameForEASProjectSync(exp, actor),
-        exp,
-        await ensureLoggedInAsync({ nonInteractive: options.nonInteractive })
-      ),
       projectName: exp.slug,
       privacy: toAppPrivacy(exp.privacy),
     },
     {
       nonInteractive: options.nonInteractive,
-    }
+    },
+    actor
   );
 
   const spinner = ora(`Linking local project to EAS project ${projectId}`).start();

packages/eas-cli/src/submit/android/__tests__/AndroidSubmitCommand-test.ts

@@ -15,7 +15,7 @@ import {
 } from '../../../graphql/generated';
 import { SubmissionMutation } from '../../../graphql/mutations/SubmissionMutation';
 import { createTestProject } from '../../../project/__tests__/project-utils';
-import { getOwnerAccountForProjectIdAsync, getProjectIdAsync } from '../../../project/projectUtils';
+import { getOwnerAccountForProjectIdAsync } from '../../../project/projectUtils';
 import { createSubmissionContextAsync } from '../../context';
 import { getRecentBuildsForSubmissionAsync } from '../../utils/builds';
 import AndroidSubmitCommand from '../AndroidSubmitCommand';
@@ -78,10 +78,6 @@ describe(AndroidSubmitCommand, () => {
     jest.mocked(getOwnerAccountForProjectIdAsync).mockResolvedValue(mockJester.accounts[0]);
   });
 
-  afterEach(() => {
-    jest.mocked(getProjectIdAsync).mockClear();
-  });
-
   describe('non-interactive mode', () => {
     it("throws error if didn't provide serviceAccountKeyPath in the submit profile", async () => {
       const projectId = uuidv4();
@@ -99,6 +95,7 @@ describe(AndroidSubmitCommand, () => {
           changesNotSentForReview: false,
         },
         nonInteractive: true,
+        actor: mockJester,
       });
       const command = new AndroidSubmitCommand(ctx);
       await expect(command.runAsync()).rejects.toThrowError();
@@ -123,6 +120,7 @@ describe(AndroidSubmitCommand, () => {
           changesNotSentForReview: false,
         },
         nonInteractive: false,
+        actor: mockJester,
       });
       const command = new AndroidSubmitCommand(ctx);
       await command.runAsync();
@@ -159,6 +157,7 @@ describe(AndroidSubmitCommand, () => {
           changesNotSentForReview: false,
         },
         nonInteractive: false,
+        actor: mockJester,
       });
       const command = new AndroidSubmitCommand(ctx);
       await command.runAsync();

packages/eas-cli/src/submit/android/__tests__/ServiceAccountSource-test.ts

@@ -153,6 +153,7 @@ describe(getServiceAccountKeyResultAsync, () => {
         changesNotSentForReview: false,
       },
       nonInteractive: true,
+      actor: mockJester,
     });
     const source: ServiceAccountSource = {
       sourceType: ServiceAccountSourceType.path,
@@ -188,6 +189,7 @@ describe(getServiceAccountKeyResultAsync, () => {
         changesNotSentForReview: false,
       },
       nonInteractive: true,
+      actor: mockJester,
     });
     const source: ServiceAccountSource = {
       sourceType: ServiceAccountSourceType.prompt,
@@ -219,6 +221,7 @@ describe(getServiceAccountKeyResultAsync, () => {
         changesNotSentForReview: false,
       },
       nonInteractive: true,
+      actor: mockJester,
     });
     const serviceAccountResult = await getServiceAccountKeyResultAsync(ctx, {
       sourceType: ServiceAccountSourceType.credentialsService,

packages/eas-cli/src/submit/context.ts

@@ -9,7 +9,6 @@ import { CredentialsContext } from '../credentials/context';
 import { getExpoConfig } from '../project/expoConfig';
 import { getOwnerAccountForProjectIdAsync } from '../project/projectUtils';
 import { Actor } from '../user/User';
-import { ensureLoggedInAsync } from '../user/actions';
 
 export interface SubmissionContext<T extends Platform> {
   accountName: string;
@@ -44,17 +43,22 @@ export async function createSubmissionContextAsync<T extends Platform>(params: {
   projectDir: string;
   projectId: string;
   applicationIdentifier?: string;
+  actor: Actor;
 }): Promise<SubmissionContext<T>> {
-  const { applicationIdentifier, projectDir, nonInteractive } = params;
+  const { applicationIdentifier, projectDir, nonInteractive, actor } = params;
   const exp = getExpoConfig(projectDir, { env: params.env });
   const { env, ...rest } = params;
-  const user = await ensureLoggedInAsync({ nonInteractive });
   const projectName = exp.slug;
   const account = await getOwnerAccountForProjectIdAsync(params.projectId);
   const accountId = account.id;
   let credentialsCtx: CredentialsContext | undefined = params.credentialsCtx;
   if (!credentialsCtx) {
-    credentialsCtx = new CredentialsContext({ projectDir, user, exp, nonInteractive });
+    credentialsCtx = new CredentialsContext({
+      projectDir,
+      user: actor,
+      projectInfo: { exp, projectId: params.projectId },
+      nonInteractive,
+    });
   }
 
   const trackingCtx = {
@@ -72,7 +76,7 @@ export async function createSubmissionContextAsync<T extends Platform>(params: {
     credentialsCtx,
     exp,
     projectName,
-    user,
+    user: actor,
     trackingCtx,
     applicationIdentifierOverride: applicationIdentifier,
   };

packages/eas-cli/src/submit/ios/__tests__/AscApiKeySource-test.ts

@@ -50,6 +50,7 @@ async function getIosSubmissionContextAsync(): Promise<SubmissionContext<Platfor
       language: 'en-US',
     },
     nonInteractive: true,
+    actor: mockJester,
   });
 }
 

packages/eas-cli/src/submit/ios/__tests__/CredentialsServiceSource-test.ts

@@ -59,6 +59,7 @@ describe(getFromCredentialsServiceAsync, () => {
         language: 'en-US',
       },
       nonInteractive: false,
+      actor: mockJester,
     });
     jest
       .spyOn(SetUpSubmissionCredentials.prototype, 'runAsync')
@@ -86,6 +87,7 @@ describe(getFromCredentialsServiceAsync, () => {
         language: 'en-US',
       },
       nonInteractive: true,
+      actor: mockJester,
     });
     jest
       .spyOn(SetUpSubmissionCredentials.prototype, 'runAsync')

packages/eas-cli/src/submit/ios/__tests__/IosSubmitCommand-test.ts

@@ -8,7 +8,7 @@ import {
 } from '../../../credentials/__tests__/fixtures-constants';
 import { SubmissionMutation } from '../../../graphql/mutations/SubmissionMutation';
 import { createTestProject } from '../../../project/__tests__/project-utils';
-import { getOwnerAccountForProjectIdAsync, getProjectIdAsync } from '../../../project/projectUtils';
+import { getOwnerAccountForProjectIdAsync } from '../../../project/projectUtils';
 import { createSubmissionContextAsync } from '../../context';
 import IosSubmitCommand from '../IosSubmitCommand';
 
@@ -54,10 +54,6 @@ describe(IosSubmitCommand, () => {
     jest.mocked(getOwnerAccountForProjectIdAsync).mockResolvedValue(mockJester.accounts[0]);
   });
 
-  afterEach(() => {
-    jest.mocked(getProjectIdAsync).mockClear();
-  });
-
   describe('non-interactive mode', () => {
     it("throws error if didn't provide appleId and ascAppId in the submit profile", async () => {
       const projectId = uuidv4();
@@ -73,6 +69,7 @@ describe(IosSubmitCommand, () => {
           language: 'en-US',
         },
         nonInteractive: true,
+        actor: mockJester,
       });
       const command = new IosSubmitCommand(ctx);
       await expect(command.runAsync()).rejects.toThrowError();
@@ -98,6 +95,7 @@ describe(IosSubmitCommand, () => {
           ascAppId: '12345678',
         },
         nonInteractive: false,
+        actor: mockJester,
       });
       const command = new IosSubmitCommand(ctx);
       await command.runAsync();

packages/eas-cli/src/update/android/UpdatesModule.ts

@@ -2,16 +2,15 @@ import { ExpoConfig } from '@expo/config';
 import { AndroidConfig, AndroidManifest } from '@expo/config-plugins';
 
 import { RequestedPlatform } from '../../platform';
-import { getOwnerAccountForProjectIdAsync, getProjectIdAsync } from '../../project/projectUtils';
+import { getOwnerAccountForProjectIdAsync } from '../../project/projectUtils';
 import { ensureValidVersions } from '../utils';
 
 export async function syncUpdatesConfigurationAsync(
   projectDir: string,
   exp: ExpoConfig,
-  { nonInteractive }: { nonInteractive: boolean }
+  projectId: string
 ): Promise<void> {
   ensureValidVersions(exp, RequestedPlatform.Android);
-  const projectId = await getProjectIdAsync(exp, { nonInteractive });
   const accountName = (await getOwnerAccountForProjectIdAsync(projectId)).name;
 
   const androidManifestPath = await AndroidConfig.Paths.getAndroidManifestAsync(projectDir);

packages/eas-cli/src/update/ios/UpdatesModule.ts

@@ -2,7 +2,7 @@ import { ExpoConfig } from '@expo/config';
 import { IOSConfig } from '@expo/config-plugins';
 
 import { RequestedPlatform } from '../../platform';
-import { getOwnerAccountForProjectIdAsync, getProjectIdAsync } from '../../project/projectUtils';
+import { getOwnerAccountForProjectIdAsync } from '../../project/projectUtils';
 import { readPlistAsync, writePlistAsync } from '../../utils/plist';
 import { getVcsClient } from '../../vcs';
 import { ensureValidVersions } from '../utils';
@@ -10,10 +10,9 @@ import { ensureValidVersions } from '../utils';
 export async function syncUpdatesConfigurationAsync(
   projectDir: string,
   exp: ExpoConfig,
-  { nonInteractive }: { nonInteractive: boolean }
+  projectId: string
 ): Promise<void> {
   ensureValidVersions(exp, RequestedPlatform.Ios);
-  const projectId = await getProjectIdAsync(exp, { nonInteractive });
   const accountName = (await getOwnerAccountForProjectIdAsync(projectId)).name;
   const expoPlist = await readExpoPlistAsync(projectDir);
   const updatedExpoPlist = IOSConfig.Updates.setUpdatesConfig(