v16.23.0

Co-authored-by: Kadi Kraman <[email protected]>

CHANGELOG.md

@@ -7,10 +7,50 @@ This is the log of notable changes to EAS CLI and related packages.
 ### 🛠 Breaking changes
 
 ### 🎉 New features
+- Support custom environment variable environments ([#3220](https://github.com/expo/eas-cli/pull/3220) by [@kadikraman](https://github.com/kadikraman))
+
+- Add --force flag to eas env:push command to bypass confirmation prompts. ([#3135](https://github.com/expo/eas-cli/pull/3135) by [@giorgiofellipe](https://github.com/giorgiofellipe))
 
 ### 🐛 Bug fixes
 
 ### 🧹 Chores
+
+## [16.22.0](https://github.com/expo/eas-cli/releases/tag/v16.22.0) - 2025-10-13
+
+### 🎉 New features
+
+- Improvements to workflow:create. ([#3194](https://github.com/expo/eas-cli/pull/3194) by [@douglowder](https://github.com/douglowder))
+
+## [16.21.0](https://github.com/expo/eas-cli/releases/tag/v16.21.0) - 2025-10-13
+
+### 🎉 New features
+
+- Support `_expo/.routes.json` metadata file exported by `@expo/cli` for headers configuration on static deployments ([#3211](https://github.com/expo/eas-cli/pull/3211) by [@kitten](https://github.com/kitten))
+
+### 🧹 Chores
+
+- Add thorough tests for the env commands ([#3217](https://github.com/expo/eas-cli/pull/3217) by [@kadikraman](https://github.com/kadikraman))
+
+## [16.20.4](https://github.com/expo/eas-cli/releases/tag/v16.20.4) - 2025-10-08
+
+### 🎉 New features
+
+- Allow workflow:run to run a workflow from a GitHub ref. ([#3203](https://github.com/expo/eas-cli/pull/3203) by [@douglowder](https://github.com/douglowder))
+
+### 🐛 Bug fixes
+
+- Fix --environment flag in eas exec and pull ([#3216](https://github.com/expo/eas-cli/pull/3216) by [@kadikraman](https://github.com/kadikraman))
+
+## [16.20.3](https://github.com/expo/eas-cli/releases/tag/v16.20.3) - 2025-10-07
+
+### 🐛 Bug fixes
+
+- Fix --environment flag in eas env commands ([#3213](https://github.com/expo/eas-cli/pull/3213) by [@kadikraman](https://github.com/kadikraman))
+
+## [16.20.2](https://github.com/expo/eas-cli/releases/tag/v16.20.2) - 2025-10-07
+
+### 🧹 Chores
+
 - Create an `EnvironmentVariableEnvironment` enum and use it instead of the graphQL Enum ([#3208](https://github.com/expo/eas-cli/pull/3208) by [@kadikraman](https://github.com/kadikraman))
 
 ## [16.20.1](https://github.com/expo/eas-cli/releases/tag/v16.20.1) - 2025-10-03

lerna.json

@@ -1,5 +1,5 @@
 {
   "npmClient": "yarn",
-  "version": "16.20.2",
+  "version": "16.23.0",
   "$schema": "node_modules/lerna/schemas/lerna-schema.json"
 }

packages/eas-cli/graphql.schema.json

@@ -1470,6 +1470,30 @@
             "isDeprecated": false,
             "deprecationReason": null
           },
+          {
+            "name": "environmentVariableEnvironments",
+            "description": null,
+            "args": [],
+            "type": {
+              "kind": "NON_NULL",
+              "name": null,
+              "ofType": {
+                "kind": "LIST",
+                "name": null,
+                "ofType": {
+                  "kind": "NON_NULL",
+                  "name": null,
+                  "ofType": {
+                    "kind": "SCALAR",
+                    "name": "EnvironmentVariableEnvironment",
+                    "ofType": null
+                  }
+                }
+              }
+            },
+            "isDeprecated": false,
+            "deprecationReason": null
+          },
           {
             "name": "environmentVariables",
             "description": "Environment variables for an account",
@@ -8983,6 +9007,30 @@
             "isDeprecated": false,
             "deprecationReason": null
           },
+          {
+            "name": "environmentVariableEnvironments",
+            "description": null,
+            "args": [],
+            "type": {
+              "kind": "NON_NULL",
+              "name": null,
+              "ofType": {
+                "kind": "LIST",
+                "name": null,
+                "ofType": {
+                  "kind": "NON_NULL",
+                  "name": null,
+                  "ofType": {
+                    "kind": "SCALAR",
+                    "name": "EnvironmentVariableEnvironment",
+                    "ofType": null
+                  }
+                }
+              }
+            },
+            "isDeprecated": false,
+            "deprecationReason": null
+          },
           {
             "name": "environmentVariables",
             "description": "Environment variables for an app",

packages/eas-cli/package.json

@@ -1,7 +1,7 @@
 {
   "name": "eas-cli",
   "description": "EAS command line tool",
-  "version": "16.20.2",
+  "version": "16.23.0",
   "author": "Expo <[email protected]>",
   "bin": {
     "eas": "./bin/run"
@@ -12,8 +12,8 @@
     "@expo/code-signing-certificates": "0.0.5",
     "@expo/config": "10.0.6",
     "@expo/config-plugins": "9.0.12",
-    "@expo/eas-build-job": "1.0.231",
-    "@expo/eas-json": "16.20.1",
+    "@expo/eas-build-job": "1.0.237",
+    "@expo/eas-json": "16.23.0",
     "@expo/env": "^1.0.0",
     "@expo/json-file": "8.3.3",
     "@expo/logger": "1.0.221",

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

@@ -8,7 +8,6 @@ import {
   transformProjectArchive,
   transformWorkflow,
 } from '../graphql';
-import { buildProfileEnvironmentToEnvironment } from '../utils/environment';
 
 export function transformJob(job: Android.Job): AndroidJobInput {
   return {
@@ -30,7 +29,7 @@ export function transformJob(job: Android.Job): AndroidJobInput {
     experimental: job.experimental,
     mode: transformBuildMode(job.mode),
     customBuildConfig: job.customBuildConfig,
-    environment: buildProfileEnvironmentToEnvironment(job.environment),
+    environment: job.environment,
     loggerLevel: job.loggerLevel
       ? loggerLevelToGraphQLWorkerLoggerLevel[job.loggerLevel]
       : undefined,

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

@@ -1,7 +1,7 @@
 import { Env } from '@expo/eas-build-job';
 import { BuildProfile } from '@expo/eas-json';
 
-import { EnvironmentVariableEnvironment, isEnvironment } from './utils/environment';
+import { DefaultEnvironment } from './utils/environment';
 import { ExpoGraphqlClient } from '../commandUtils/context/contextUtils/createGraphqlClient';
 import { EnvironmentVariablesQuery } from '../graphql/queries/EnvironmentVariablesQuery';
 import Log, { learnMore } from '../log';
@@ -48,20 +48,9 @@ async function resolveEnvVarsAsync({
   projectId: string;
 }): Promise<Env> {
   const environment =
-    buildProfile.environment?.toUpperCase() ??
+    buildProfile.environment ??
     resolveSuggestedEnvironmentForBuildProfileConfiguration(buildProfile);
 
-  if (!isEnvironment(environment)) {
-    Log.log(
-      `Loaded "env" configuration for the "${buildProfileName}" profile: ${
-        buildProfile.env && Object.keys(buildProfile.env).length > 0
-          ? Object.keys(buildProfile.env).join(', ')
-          : 'no environment variables specified'
-      }. ${learnMore('https://docs.expo.dev/build-reference/variables/')}`
-    );
-    return { ...buildProfile.env };
-  }
-
   try {
     const environmentVariables = await EnvironmentVariablesQuery.byAppIdWithSensitiveAsync(
       graphqlClient,
@@ -128,16 +117,16 @@ async function resolveEnvVarsAsync({
 
 function resolveSuggestedEnvironmentForBuildProfileConfiguration(
   buildProfile: BuildProfile
-): EnvironmentVariableEnvironment {
+): DefaultEnvironment {
   const environment =
     buildProfile.distribution === 'store'
-      ? EnvironmentVariableEnvironment.Production
+      ? DefaultEnvironment.Production
       : buildProfile.developmentClient
-        ? EnvironmentVariableEnvironment.Development
-        : EnvironmentVariableEnvironment.Preview;
+        ? DefaultEnvironment.Development
+        : DefaultEnvironment.Preview;
 
   Log.log(
-    `Resolved "${environment.toLowerCase()}" environment for the build. ${learnMore(
+    `Resolved "${environment}" environment for the build. ${learnMore(
       'https://docs.expo.dev/eas/environment-variables/#setting-the-environment-for-your-builds'
     )}`
   );

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

@@ -9,7 +9,6 @@ import {
   transformProjectArchive,
   transformWorkflow,
 } from '../graphql';
-import { buildProfileEnvironmentToEnvironment } from '../utils/environment';
 
 export function transformJob(job: Ios.Job): IosJobInput {
   return {
@@ -32,7 +31,7 @@ export function transformJob(job: Ios.Job): IosJobInput {
     experimental: job.experimental,
     mode: transformBuildMode(job.mode),
     customBuildConfig: job.customBuildConfig,
-    environment: buildProfileEnvironmentToEnvironment(job.environment),
+    environment: job.environment,
     loggerLevel: job.loggerLevel
       ? loggerLevelToGraphQLWorkerLoggerLevel[job.loggerLevel]
       : undefined,

packages/eas-cli/src/build/utils/environment.ts

@@ -1,31 +1,5 @@
-import { BuildProfile } from '@expo/eas-json';
-
-type Environment = NonNullable<BuildProfile['environment']>;
-
-// Default environments
-export enum EnvironmentVariableEnvironment {
+export enum DefaultEnvironment {
   Development = 'development',
   Preview = 'preview',
   Production = 'production',
 }
-
-const BuildProfileEnvironmentToEnvironment: Record<Environment, EnvironmentVariableEnvironment> = {
-  production: EnvironmentVariableEnvironment.Production,
-  preview: EnvironmentVariableEnvironment.Preview,
-  development: EnvironmentVariableEnvironment.Development,
-};
-
-export function isEnvironment(env: string): env is EnvironmentVariableEnvironment {
-  return Object.values(EnvironmentVariableEnvironment).includes(
-    env as EnvironmentVariableEnvironment
-  );
-}
-
-export function buildProfileEnvironmentToEnvironment(
-  environment: BuildProfile['environment']
-): EnvironmentVariableEnvironment | null {
-  if (!environment) {
-    return null;
-  }
-  return BuildProfileEnvironmentToEnvironment[environment];
-}

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

@@ -26,7 +26,6 @@ import {
   CommandEvent,
   createAnalyticsAsync,
 } from '../analytics/AnalyticsManager';
-import { EnvironmentVariableEnvironment } from '../build/utils/environment';
 import Log, { link } from '../log';
 import SessionManager from '../user/SessionManager';
 import { Client } from '../vcs/vcs';
@@ -60,7 +59,7 @@ interface BaseGetContextAsyncArgs {
 
 interface GetContextAsyncArgsWithRequiredServerSideEnvironmentArgument
   extends BaseGetContextAsyncArgs {
-  withServerSideEnvironment: EnvironmentVariableEnvironment | null;
+  withServerSideEnvironment: string | null;
 }
 
 interface GetContextAsyncArgsWithoutServerSideEnvironmentArgument extends BaseGetContextAsyncArgs {

packages/eas-cli/src/commandUtils/context/ContextField.ts

@@ -1,5 +1,4 @@
 import { Analytics } from '../../analytics/AnalyticsManager';
-import { EnvironmentVariableEnvironment } from '../../build/utils/environment';
 import SessionManager from '../../user/SessionManager';
 import { Client } from '../../vcs/vcs';
 
@@ -11,7 +10,7 @@ export interface ContextOptions {
   /**
    * If specified, env variables from the selected environment will be fetched from the server and used to evaluate the dynamic config.
    */
-  withServerSideEnvironment?: EnvironmentVariableEnvironment | null;
+  withServerSideEnvironment?: string | null;
 }
 
 export default abstract class ContextField<T> {

packages/eas-cli/src/commandUtils/context/contextUtils/loadServerSideEnvironmentVariablesAsync.ts

@@ -1,23 +1,15 @@
 import { ExpoGraphqlClient } from './createGraphqlClient';
-import { EnvironmentVariableEnvironment } from '../../../build/utils/environment';
 import { EnvironmentVariablesQuery } from '../../../graphql/queries/EnvironmentVariablesQuery';
 import Log from '../../../log';
 
-const cachedServerSideEnvironmentVariables: Record<
-  EnvironmentVariableEnvironment,
-  Record<string, string> | null
-> = {
-  [EnvironmentVariableEnvironment.Development]: null,
-  [EnvironmentVariableEnvironment.Preview]: null,
-  [EnvironmentVariableEnvironment.Production]: null,
-};
+const cachedServerSideEnvironmentVariables: Record<string, Record<string, string> | undefined> = {};
 
 export async function loadServerSideEnvironmentVariablesAsync({
   environment,
   projectId,
   graphqlClient,
 }: {
-  environment: EnvironmentVariableEnvironment;
+  environment: string;
   projectId: string;
   graphqlClient: ExpoGraphqlClient;
 }): Promise<Record<string, string>> {
@@ -42,13 +34,13 @@ export async function loadServerSideEnvironmentVariablesAsync({
 
   if (Object.keys(serverEnvVars).length > 0) {
     Log.log(
-      `Environment variables with visibility "Plain text" and "Sensitive" loaded from the "${environment.toLowerCase()}" environment on EAS: ${Object.keys(
+      `Environment variables with visibility "Plain text" and "Sensitive" loaded from the "${environment}" environment on EAS: ${Object.keys(
         serverEnvVars
       ).join(', ')}.`
     );
   } else {
     Log.log(
-      `No environment variables with visibility "Plain text" and "Sensitive" found for the "${environment.toLowerCase()}" environment on EAS.`
+      `No environment variables with visibility "Plain text" and "Sensitive" found for the "${environment}" environment on EAS.`
     );
   }
   Log.newLine();

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

@@ -1,17 +1,5 @@
 import { Flags } from '@oclif/core';
 
-import { EnvironmentVariableEnvironment } from '../build/utils/environment';
-
-// NOTE: not exactly true, but, provided mapToLowercase and upperCaseAsync
-// are used in tandem, it saves on unnecessary typying in commands
-async function upperCaseAsync<T>(input: string): Promise<T> {
-  return input.toUpperCase() as T;
-}
-
-function mapToLowercase<T extends string>(options: T[]): T[] {
-  return options.map(option => option.toLowerCase()) as T[];
-}
-
 export const EasNonInteractiveAndJsonFlags = {
   json: Flags.boolean({
     description: 'Enable JSON output, non-JSON messages will be printed to stderr.',
@@ -23,20 +11,17 @@ export const EasNonInteractiveAndJsonFlags = {
 };
 
 export const EasEnvironmentFlagParameters = {
-  description: "Environment variable's environment",
-  options: mapToLowercase([
-    EnvironmentVariableEnvironment.Development,
-    EnvironmentVariableEnvironment.Preview,
-    EnvironmentVariableEnvironment.Production,
-  ]),
+  description: "Environment variable's environment, e.g. 'production', 'preview', 'development'",
 };
 
 export const EASEnvironmentFlag = {
-  environment: Flags.enum<EnvironmentVariableEnvironment>(EasEnvironmentFlagParameters),
+  environment: Flags.string({
+    description: "Environment variable's environment, e.g. 'production', 'preview', 'development'",
+  }),
 };
 
 export const EASMultiEnvironmentFlag = {
-  environment: Flags.enum<EnvironmentVariableEnvironment>({
+  environment: Flags.string({
     ...EasEnvironmentFlagParameters,
     multiple: true,
   }),
@@ -80,12 +65,10 @@ export const EasJsonOnlyFlag = {
 };
 
 export const EasUpdateEnvironmentFlag = {
-  environment: Flags.enum<EnvironmentVariableEnvironment | null>({
+  environment: Flags.string({
     description:
-      'Environment to use for the server-side defined EAS environment variables during command execution.',
-    options: mapToLowercase(Object.values(EnvironmentVariableEnvironment)),
-    parse: upperCaseAsync,
+      'Environment to use for the server-side defined EAS environment variables during command execution, e.g. "production", "preview", "development"',
     required: false,
-    default: null,
+    default: undefined,
   }),
 };

packages/eas-cli/src/commandUtils/workflow/buildProfileUtils.ts

@@ -0,0 +1,269 @@
+import { ExpoConfig } from '@expo/config';
+import { BuildProfile, EasJsonAccessor, EasJsonUtils, Platform } from '@expo/eas-json';
+import { AndroidBuildProfile, IosBuildProfile } from '@expo/eas-json/build/build/types';
+
+import BuildConfigure from '../../commands/build/configure';
+import UpdateConfigure from '../../commands/update/configure';
+import Log from '../../log';
+import { promptAsync } from '../../prompts';
+
+export async function buildProfileNamesFromProjectAsync(projectDir: string): Promise<Set<string>> {
+  const easJsonAccessor = EasJsonAccessor.fromProjectPath(projectDir);
+
+  const buildProfileNames = new Set(
+    easJsonAccessor && (await EasJsonUtils.getBuildProfileNamesAsync(easJsonAccessor))
+  );
+  return buildProfileNames;
+}
+export async function getBuildProfileAsync(
+  projectDir: string,
+  platform: Platform,
+  profileName: string
+): Promise<BuildProfile<Platform>> {
+  const easJsonAccessor = EasJsonAccessor.fromProjectPath(projectDir);
+  const buildProfile = await EasJsonUtils.getBuildProfileAsync(
+    easJsonAccessor,
+    platform,
+    profileName
+  );
+  return buildProfile;
+}
+export async function buildProfilesFromProjectAsync(
+  projectDir: string
+): Promise<Map<string, { android: AndroidBuildProfile; ios: IosBuildProfile }>> {
+  const buildProfileNames = await buildProfileNamesFromProjectAsync(projectDir);
+  const buildProfiles: Map<string, { android: AndroidBuildProfile; ios: IosBuildProfile }> =
+    new Map();
+  for (const profileName of buildProfileNames) {
+    const iosBuildProfile = (await getBuildProfileAsync(
+      projectDir,
+      Platform.IOS,
+      profileName
+    )) as IosBuildProfile;
+    const androidBuildProfile = (await getBuildProfileAsync(
+      projectDir,
+      Platform.ANDROID,
+      profileName
+    )) as AndroidBuildProfile;
+    buildProfiles.set(profileName, { android: androidBuildProfile, ios: iosBuildProfile });
+  }
+  return buildProfiles;
+}
+export function isBuildProfileForDevelopment(
+  buildProfile: BuildProfile<Platform>,
+  platform: Platform
+): boolean {
+  if (buildProfile.developmentClient) {
+    return true;
+  }
+  if (platform === Platform.ANDROID) {
+    return (buildProfile as BuildProfile<Platform.ANDROID>).gradleCommand === ':app:assembleDebug';
+  }
+  if (platform === Platform.IOS) {
+    return (buildProfile as BuildProfile<Platform.IOS>).buildConfiguration === 'Debug';
+  }
+  return false;
+}
+export function isIosBuildProfileForSimulator(buildProfile: BuildProfile<Platform.IOS>): boolean {
+  return buildProfile.simulator ?? false;
+}
+export async function addAndroidDevelopmentBuildProfileToEasJsonAsync(
+  projectDir: string,
+  buildProfileName: string
+): Promise<void> {
+  const easJsonAccessor = EasJsonAccessor.fromProjectPath(projectDir);
+  await easJsonAccessor.readRawJsonAsync();
+  easJsonAccessor.patch(easJsonRawObject => {
+    easJsonRawObject.build = {
+      ...easJsonRawObject.build,
+      [buildProfileName]: {
+        developmentClient: true,
+        distribution: 'internal',
+        android: {
+          gradleCommand: ':app:assembleDebug',
+        },
+      },
+    };
+    return easJsonRawObject;
+  });
+  await easJsonAccessor.writeAsync();
+}
+export async function addIosDevelopmentBuildProfileToEasJsonAsync(
+  projectDir: string,
+  buildProfileName: string,
+  simulator: boolean
+): Promise<void> {
+  const easJsonAccessor = EasJsonAccessor.fromProjectPath(projectDir);
+  await easJsonAccessor.readRawJsonAsync();
+  easJsonAccessor.patch(easJsonRawObject => {
+    easJsonRawObject.build = {
+      ...easJsonRawObject.build,
+      [buildProfileName]: {
+        developmentClient: true,
+        distribution: 'internal',
+        ios: {
+          buildConfiguration: 'Debug',
+          simulator,
+        },
+      },
+    };
+    return easJsonRawObject;
+  });
+  await easJsonAccessor.writeAsync();
+}
+
+export async function addProductionBuildProfileToEasJsonIfNeededAsync(
+  projectDir: string
+): Promise<boolean> {
+  const easJsonAccessor = EasJsonAccessor.fromProjectPath(projectDir);
+  await easJsonAccessor.readRawJsonAsync();
+  let profileAdded = false;
+  easJsonAccessor.patch(easJsonRawObject => {
+    if (!easJsonRawObject.build?.production) {
+      profileAdded = true;
+      easJsonRawObject.build = {
+        ...(easJsonRawObject.build ?? {}),
+        production: {},
+      };
+      // Also add the profile to submit
+      easJsonRawObject.submit = {
+        ...(easJsonRawObject.submit ?? {}),
+        production: {},
+      };
+    }
+    return easJsonRawObject;
+  });
+  if (profileAdded) {
+    Log.log('Added missing production build profile to eas.json');
+  }
+  await easJsonAccessor.writeAsync();
+  return profileAdded;
+}
+
+export async function hasBuildConfigureBeenRunAsync({
+  projectDir,
+  expoConfig,
+}: {
+  projectDir: string;
+  expoConfig: ExpoConfig;
+}): Promise<boolean> {
+  // Is there a project ID in the Expo config?
+  if (!expoConfig.extra?.eas?.projectId) {
+    return false;
+  }
+  // Is there an eas.json?
+  const easJsonAccessor = EasJsonAccessor.fromProjectPath(projectDir);
+  try {
+    await easJsonAccessor.readAsync();
+  } catch {
+    return false;
+  }
+  return true;
+}
+
+export async function hasUpdateConfigureBeenRunAsync({
+  projectDir,
+  expoConfig,
+}: {
+  projectDir: string;
+  expoConfig: ExpoConfig;
+}): Promise<boolean> {
+  // Does the Expo config have an updates URL?
+  if (!expoConfig.updates?.url) {
+    return false;
+  }
+  // Does at least one build profile have a channel?
+  const easJsonAccessor = EasJsonAccessor.fromProjectPath(projectDir);
+  try {
+    const easJson = await easJsonAccessor.readAsync();
+    return Object.values(easJson.build ?? {}).some(buildProfile => !!buildProfile.channel);
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Runs update:configure if needed. Returns a boolean (proceed with workflow creation, or not)
+ */
+
+export async function runUpdateConfigureIfNeededAsync({
+  projectDir,
+  expoConfig,
+}: {
+  projectDir: string;
+  expoConfig: ExpoConfig;
+}): Promise<boolean> {
+  if (
+    await hasUpdateConfigureBeenRunAsync({
+      projectDir,
+      expoConfig,
+    })
+  ) {
+    return true;
+  }
+  const nextStep = (
+    await promptAsync({
+      type: 'select',
+      name: 'nextStep',
+      message:
+        'You have chosen to create a workflow that requires EAS Update configuration. What would you like to do?',
+      choices: [
+        { title: 'Configure EAS Update and then proceed', value: 'configure' },
+        { title: 'EAS Update is already configured, proceed', value: 'proceed' },
+        { title: 'Choose a different workflow template', value: 'repeat' },
+      ],
+    })
+  ).nextStep;
+  switch (nextStep) {
+    case 'configure':
+      Log.newLine();
+      await UpdateConfigure.run([]);
+      return true;
+    case 'proceed':
+      return true;
+    default:
+      return false;
+  }
+}
+/**
+ * Runs build:configure if needed. Returns a boolean (proceed with workflow creation, or not)
+ */
+export async function runBuildConfigureIfNeededAsync({
+  projectDir,
+  expoConfig,
+}: {
+  projectDir: string;
+  expoConfig: ExpoConfig;
+}): Promise<boolean> {
+  if (
+    await hasBuildConfigureBeenRunAsync({
+      projectDir,
+      expoConfig,
+    })
+  ) {
+    return true;
+  }
+  const nextStep = (
+    await promptAsync({
+      type: 'select',
+      name: 'nextStep',
+      message:
+        'You have chosen to create a workflow that requires EAS Build configuration. What would you like to do?',
+      choices: [
+        { title: 'Configure EAS Build and then proceed', value: 'configure' },
+        { title: 'EAS Build is already configured, proceed', value: 'proceed' },
+        { title: 'Choose a different workflow template', value: 'repeat' },
+      ],
+    })
+  ).nextStep;
+  switch (nextStep) {
+    case 'configure':
+      Log.newLine();
+      await BuildConfigure.run(['-p', 'all']);
+      return true;
+    case 'proceed':
+      return true;
+    default:
+      return false;
+  }
+}

packages/eas-cli/src/commandUtils/workflow/creation.ts

@@ -0,0 +1,536 @@
+import { ExpoConfig } from '@expo/config';
+import { Platform } from '@expo/eas-build-job';
+
+import {
+  addAndroidDevelopmentBuildProfileToEasJsonAsync,
+  addIosDevelopmentBuildProfileToEasJsonAsync,
+  addProductionBuildProfileToEasJsonIfNeededAsync,
+  buildProfilesFromProjectAsync,
+  hasBuildConfigureBeenRunAsync,
+  hasUpdateConfigureBeenRunAsync,
+  isBuildProfileForDevelopment,
+  isIosBuildProfileForSimulator,
+} from './buildProfileUtils';
+import Log, { link } from '../../log';
+import { confirmAsync } from '../../prompts';
+import { easCliVersion } from '../../utils/easCli';
+
+export enum WorkflowStarterName {
+  BUILD = 'build',
+  UPDATE = 'update',
+  CUSTOM = 'custom',
+  DEPLOY = 'deploy',
+}
+
+export type WorkflowStarter = {
+  name: WorkflowStarterName;
+  displayName: string;
+  defaultFileName: string;
+  template: any;
+  header: string;
+  nextSteps?: string[];
+};
+
+const createdByEASCLI = `# Created by EAS CLI v${easCliVersion}`;
+
+const CUSTOM_TEMPLATE = {
+  name: 'Custom workflow',
+  on: {
+    push: {
+      branches: ['main'],
+    },
+  },
+  jobs: {
+    custom_build: {
+      name: 'Custom job',
+      steps: [
+        {
+          uses: 'eas/checkout',
+        },
+        {
+          name: 'Hello World',
+          id: 'hello_world',
+          run: '# Custom script\necho "Hello, World"\n',
+        },
+      ],
+    },
+  },
+};
+
+const CUSTOM_TEMPLATE_HEADER = `
+# Custom job
+#
+# This workflow shows how to write custom jobs.
+# It contains a predefined workflow step and a shell command to print "Hello, World!".
+#
+# Key features:
+# - Triggers on pushes to the main branch.
+#    (Requires linked GitHub account: https://expo.dev/accounts/[account]/settings/github)
+# - Can be triggered manually with eas workflow:run custom.yml
+# - Runs eas/checkout then a custom "echo" command
+#
+# For detailed documentation on workflow syntax and available step types, visit:
+# https://docs.expo.dev/eas/workflows/syntax/#jobsjob_idstepsstepuses
+#
+${createdByEASCLI}
+#
+`;
+
+const BUILD_TEMPLATE = {
+  name: 'Create development builds',
+  on: {
+    push: {
+      branches: ['main'],
+    },
+  },
+  jobs: {},
+};
+
+const BUILD_TEMPLATE_HEADER = `
+# Create development builds
+#
+# This workflow shows how to create development builds.
+#
+# Key features:
+# - Can be triggered manually with eas workflow:run create-development-builds.yml
+# - Runs the pre-packaged build job to create Android and iOS development builds
+#     for Android emulators, Android and iOS devices, and iOS simulators
+#
+# For a detailed guide on using this workflow, visit:
+# https://docs.expo.dev/develop/development-builds/introduction/
+#
+${createdByEASCLI}
+#
+`;
+
+const PUBLISH_UPDATE_TEMPLATE = {
+  name: 'Publish preview update',
+  on: {
+    push: {
+      branches: ['*'],
+    },
+  },
+  jobs: {
+    publish_preview_update: {
+      name: 'Publish preview update',
+      type: 'update',
+      params: {
+        branch: '${{ github.ref_name || "test" }}',
+      },
+    },
+  },
+};
+
+const PUBLISH_UPDATE_TEMPLATE_HEADER = `
+# Publish preview update
+#
+# This workflow shows how to publish preview updates.
+# Learn more: https://docs.expo.dev/review/share-previews-with-your-team/
+#
+# Key features:
+# - Triggers on pushes to all branches
+#    (Requires linked GitHub account: https://expo.dev/accounts/[account]/settings/github)
+# - Can be triggered manually with eas workflow:run publish-preview-update.yml
+# - Runs the pre-packaged update job
+#
+# For a detailed guide on using this workflow, visit:
+# https://docs.expo.dev/eas/workflows/examples/publish-preview-update/
+#
+${createdByEASCLI}
+#
+`;
+
+const DEPLOY_TEMPLATE = {
+  name: 'Deploy to production',
+  on: {
+    push: {
+      branches: ['main'],
+    },
+  },
+  jobs: {
+    fingerprint: {
+      name: 'Fingerprint',
+      type: 'fingerprint',
+    },
+    get_android_build: {
+      name: 'Check for existing android build',
+      needs: ['fingerprint'],
+      type: 'get-build',
+      params: {
+        fingerprint_hash: '${{ needs.fingerprint.outputs.android_fingerprint_hash }}',
+        profile: 'production',
+      },
+    },
+    get_ios_build: {
+      name: 'Check for existing ios build',
+      needs: ['fingerprint'],
+      type: 'get-build',
+      params: {
+        fingerprint_hash: '${{ needs.fingerprint.outputs.ios_fingerprint_hash }}',
+        profile: 'production',
+      },
+    },
+    build_android: {
+      name: 'Build Android',
+      needs: ['get_android_build'],
+      if: '${{ !needs.get_android_build.outputs.build_id }}',
+      type: 'build',
+      params: {
+        platform: 'android',
+        profile: 'production',
+      },
+    },
+    build_ios: {
+      name: 'Build iOS',
+      needs: ['get_ios_build'],
+      if: '${{ !needs.get_ios_build.outputs.build_id }}',
+      type: 'build',
+      params: {
+        platform: 'ios',
+        profile: 'production',
+      },
+    },
+    submit_android_build: {
+      name: 'Submit Android Build',
+      needs: ['build_android'],
+      type: 'submit',
+      params: {
+        build_id: '${{ needs.build_android.outputs.build_id }}',
+      },
+    },
+    submit_ios_build: {
+      name: 'Submit iOS Build',
+      needs: ['build_ios'],
+      type: 'submit',
+      params: {
+        build_id: '${{ needs.build_ios.outputs.build_id }}',
+      },
+    },
+    publish_android_update: {
+      name: 'Publish Android update',
+      needs: ['get_android_build'],
+      if: '${{ needs.get_android_build.outputs.build_id }}',
+      type: 'update',
+      params: {
+        branch: 'production',
+        platform: 'android',
+      },
+    },
+    publish_ios_update: {
+      name: 'Publish iOS update',
+      needs: ['get_ios_build'],
+      if: '${{ needs.get_ios_build.outputs.build_id }}',
+      type: 'update',
+      params: {
+        branch: 'production',
+        platform: 'ios',
+      },
+    },
+  },
+};
+
+const DEPLOY_TEMPLATE_HEADER = `
+# Deploy to production
+#
+# This workflow shows how to build and submit to app stores.
+#
+# Key features:
+# - Triggers on pushes to "main" (Requires linked GitHub account: https://expo.dev/accounts/[account]/settings/github)
+# - Can be triggered manually with eas workflow:run deploy-to-production.yml
+# - Creates builds and submits them to app stores when native changes are detected, otherwise sends an over-the-air update.
+#
+# For a detailed guide on using this workflow, visit:
+# https://docs.expo.dev/eas/workflows/examples/deploy-to-production/
+`;
+
+function nextStepForDeviceBuildProfile(buildProfileName: string): string {
+  return `A build job in this workflow uses the build profile "${buildProfileName}"
+    to build your app for real devices, and may require credentials.
+    You can configure your credentials with the command "eas credentials".
+    For more information, please see ${link('https://docs.expo.dev/app-signing/app-credentials/')}.
+`
+    .trim()
+    .trimStart();
+}
+
+function nextStepForAppSubmission(): string {
+  return `This workflow includes a job to submit your app to app stores.
+    You will need to configure your App Store/Play Store credentials 
+    before you can run this workflow.
+    Please see ${link('https://docs.expo.dev/deploy/submit-to-app-stores/')}.
+  `
+    .trim()
+    .trimStart();
+}
+
+export function howToRunWorkflow(
+  workflowFileName: string,
+  workflowStarter: WorkflowStarter
+): string {
+  const lines = [
+    `To run this workflow manually, use the command "eas workflow:run .eas/workflows/${workflowFileName}".`,
+  ];
+  if (workflowStarter.template?.on?.push?.branches?.length > 0) {
+    const branches = workflowStarter.template.on.push.branches;
+    if (branches.length === 1 && branches[0] === '*') {
+      lines.push(
+        'This workflow is also configured to run automatically when code is pushed to any branch.'
+      );
+    } else if (branches.length === 1) {
+      lines.push(
+        `This workflow is also configured to run automatically when code is pushed to the "${branches[0]}" branch.`
+      );
+    } else {
+      lines.push(
+        `This workflow is also configured to run automatically when code is pushed to the following branches: ${branches.join(
+          ', '
+        )}.`
+      );
+    }
+  }
+  return lines.join('\n');
+}
+
+export const workflowStarters: WorkflowStarter[] = [
+  {
+    displayName: 'Custom',
+    name: WorkflowStarterName.CUSTOM,
+    defaultFileName: 'custom.yml',
+    template: CUSTOM_TEMPLATE,
+    header: CUSTOM_TEMPLATE_HEADER,
+  },
+  {
+    displayName: 'Create development builds',
+    name: WorkflowStarterName.BUILD,
+    defaultFileName: 'create-development-builds.yml',
+    template: BUILD_TEMPLATE,
+    header: BUILD_TEMPLATE_HEADER,
+  },
+  {
+    displayName: 'Publish updates',
+    name: WorkflowStarterName.UPDATE,
+    defaultFileName: 'publish-updates.yml',
+    template: PUBLISH_UPDATE_TEMPLATE,
+    header: PUBLISH_UPDATE_TEMPLATE_HEADER,
+  },
+  {
+    displayName: 'Deploy to production',
+    name: WorkflowStarterName.DEPLOY,
+    defaultFileName: 'deploy-to-production.yml',
+    template: DEPLOY_TEMPLATE,
+    header: DEPLOY_TEMPLATE_HEADER,
+  },
+];
+
+export async function addBuildJobsToDevelopmentBuildTemplateAsync(
+  projectDir: string,
+  workflowStarter: WorkflowStarter
+): Promise<WorkflowStarter> {
+  const buildProfiles = await buildProfilesFromProjectAsync(projectDir);
+  // android_development_build
+
+  const nextSteps: Set<string> = new Set();
+
+  let androidDevelopmentBuildProfileName: string | null = null;
+  for (const profileName of buildProfiles.keys()) {
+    const profile = buildProfiles.get(profileName)?.android;
+    if (!profile) {
+      continue;
+    }
+    if (isBuildProfileForDevelopment(profile, Platform.ANDROID)) {
+      androidDevelopmentBuildProfileName = profileName;
+      break;
+    }
+  }
+  if (!androidDevelopmentBuildProfileName) {
+    Log.warn(
+      'This workflow requires an Android development build profile in your eas.json, but none were found.'
+    );
+    const add = await confirmAsync({
+      message: 'Do you want to add an Android development build profile?',
+      initial: false,
+    });
+    if (add) {
+      let androidDevelopmentBuildProfileName = 'android_development';
+      while (buildProfiles.has(androidDevelopmentBuildProfileName)) {
+        androidDevelopmentBuildProfileName = `${androidDevelopmentBuildProfileName}_1`;
+      }
+      await addAndroidDevelopmentBuildProfileToEasJsonAsync(
+        projectDir,
+        androidDevelopmentBuildProfileName
+      );
+    } else {
+      Log.log('Skipping Android development build job...');
+    }
+  }
+  if (androidDevelopmentBuildProfileName) {
+    Log.log(`Using Android development build profile: ${androidDevelopmentBuildProfileName}`);
+    workflowStarter.template.jobs.android_development_build = {
+      name: `Build ${androidDevelopmentBuildProfileName} for android`,
+      type: 'build',
+      params: {
+        profile: androidDevelopmentBuildProfileName,
+        platform: 'android',
+      },
+    };
+    nextSteps.add(nextStepForDeviceBuildProfile(androidDevelopmentBuildProfileName));
+  }
+
+  // ios_simulator_development_build
+  let iosSimulatorDevelopmentBuildProfileName: string | null = null;
+  for (const profileName of buildProfiles.keys()) {
+    const profile = buildProfiles.get(profileName)?.ios;
+    if (!profile) {
+      continue;
+    }
+    if (
+      isBuildProfileForDevelopment(profile, Platform.IOS) &&
+      isIosBuildProfileForSimulator(profile)
+    ) {
+      iosSimulatorDevelopmentBuildProfileName = profileName;
+      break;
+    }
+  }
+  if (!iosSimulatorDevelopmentBuildProfileName) {
+    Log.warn(
+      'This workflow requires an iOS simulator development build profile in your eas.json, but none were found.'
+    );
+    const add = await confirmAsync({
+      message: 'Do you want to add an iOS simulator development build profile?',
+      initial: false,
+    });
+    if (add) {
+      let iosSimulatorDevelopmentBuildProfileName = 'ios_simulator_development';
+      while (buildProfiles.has(iosSimulatorDevelopmentBuildProfileName)) {
+        iosSimulatorDevelopmentBuildProfileName = `${iosSimulatorDevelopmentBuildProfileName}_1`;
+      }
+      await addIosDevelopmentBuildProfileToEasJsonAsync(
+        projectDir,
+        iosSimulatorDevelopmentBuildProfileName,
+        true
+      );
+    } else {
+      Log.log('Skipping iOS simulator development build job...');
+    }
+  }
+  if (iosSimulatorDevelopmentBuildProfileName) {
+    Log.log(
+      `Using iOS simulator development build profile: ${iosSimulatorDevelopmentBuildProfileName}`
+    );
+    workflowStarter.template.jobs.ios_simulator_development_build = {
+      name: `Build ${iosSimulatorDevelopmentBuildProfileName} for iOS simulator`,
+      type: 'build',
+      params: {
+        profile: iosSimulatorDevelopmentBuildProfileName,
+        platform: 'ios',
+      },
+    };
+  }
+  // ios_device_development_build
+  let iosDeviceDevelopmentBuildProfileName: string | null = null;
+  for (const profileName of buildProfiles.keys()) {
+    const profile = buildProfiles.get(profileName)?.ios;
+    if (!profile) {
+      continue;
+    }
+    if (
+      isBuildProfileForDevelopment(profile, Platform.IOS) &&
+      !isIosBuildProfileForSimulator(profile)
+    ) {
+      iosDeviceDevelopmentBuildProfileName = profileName;
+      break;
+    }
+  }
+  if (!iosDeviceDevelopmentBuildProfileName) {
+    Log.warn(
+      'This workflow requires an iOS device development build profile in your eas.json, but none were found.'
+    );
+    const add = await confirmAsync({
+      message: 'Do you want to add an iOS device development build profile?',
+      initial: false,
+    });
+    if (add) {
+      let iosDeviceDevelopmentBuildProfileName = 'ios_device_development';
+      while (buildProfiles.has(iosDeviceDevelopmentBuildProfileName)) {
+        iosDeviceDevelopmentBuildProfileName = `${iosDeviceDevelopmentBuildProfileName}_1`;
+      }
+      await addIosDevelopmentBuildProfileToEasJsonAsync(
+        projectDir,
+        iosDeviceDevelopmentBuildProfileName,
+        false
+      );
+    } else {
+      Log.log('Skipping iOS device development build job...');
+    }
+  }
+  if (iosDeviceDevelopmentBuildProfileName) {
+    Log.log(`Using iOS device development build profile: ${iosDeviceDevelopmentBuildProfileName}`);
+    workflowStarter.template.jobs.ios_development_build = {
+      name: `Build ${iosDeviceDevelopmentBuildProfileName} for iOS simulator`,
+      type: 'build',
+      params: {
+        profile: iosDeviceDevelopmentBuildProfileName,
+        platform: 'ios',
+      },
+    };
+    nextSteps.add(nextStepForDeviceBuildProfile(iosDeviceDevelopmentBuildProfileName));
+  }
+  workflowStarter.nextSteps = [...nextSteps];
+  return workflowStarter;
+}
+
+export async function ensureProductionBuildProfileExistsAsync(
+  projectDir: string,
+  workflowStarter: WorkflowStarter
+): Promise<WorkflowStarter> {
+  await addProductionBuildProfileToEasJsonIfNeededAsync(projectDir);
+  workflowStarter.nextSteps = [
+    nextStepForDeviceBuildProfile('production'),
+    nextStepForAppSubmission(),
+  ];
+  return workflowStarter;
+}
+
+export async function customizeTemplateIfNeededAsync(
+  workflowStarter: WorkflowStarter,
+  projectDir: string,
+  expoConfig: ExpoConfig
+): Promise<any> {
+  // Ensure EAS Build is configured
+  switch (workflowStarter.name) {
+    case WorkflowStarterName.BUILD:
+    case WorkflowStarterName.DEPLOY:
+    case WorkflowStarterName.UPDATE:
+      if (!(await hasBuildConfigureBeenRunAsync({ projectDir, expoConfig }))) {
+        throw new Error(
+          'EAS Build is not configured for this project. Please run "eas build:configure" to configure it.'
+        );
+      }
+      break;
+    default:
+      break;
+  }
+  // Ensure EAS Update is configured
+  switch (workflowStarter.name) {
+    case WorkflowStarterName.DEPLOY:
+    case WorkflowStarterName.UPDATE:
+      if (!(await hasUpdateConfigureBeenRunAsync({ projectDir, expoConfig }))) {
+        throw new Error(
+          'EAS Update is not configured for this project. Please run "eas update:configure" to configure it.'
+        );
+      }
+      break;
+    default:
+      break;
+  }
+  // Customize template
+  switch (workflowStarter.name) {
+    case WorkflowStarterName.BUILD:
+      Log.debug('Adding build jobs to template...');
+      return await addBuildJobsToDevelopmentBuildTemplateAsync(projectDir, workflowStarter);
+    case WorkflowStarterName.DEPLOY:
+      return await ensureProductionBuildProfileExistsAsync(projectDir, workflowStarter);
+    default:
+      return workflowStarter;
+  }
+}

packages/eas-cli/src/commandUtils/workflow/validation.ts

@@ -1,10 +1,10 @@
-import { EasJsonAccessor, EasJsonUtils } from '@expo/eas-json';
 import { InvalidEasJsonError, MissingEasJsonError } from '@expo/eas-json/build/errors';
 import { CombinedError } from '@urql/core';
 import { promises as fs } from 'fs';
 import path from 'path';
 import * as YAML from 'yaml';
 
+import { buildProfileNamesFromProjectAsync } from './buildProfileUtils';
 import { getExpoApiWorkflowSchemaURL } from '../../api';
 import { WorkflowRevisionMutation } from '../../graphql/mutations/WorkflowRevisionMutation';
 import Log from '../../log';
@@ -102,11 +102,8 @@ async function validateWorkflowBuildJobsAsync(parsedYaml: any, projectDir: strin
   if (buildJobs.length === 0) {
     return;
   }
-  const easJsonAccessor = EasJsonAccessor.fromProjectPath(projectDir);
+  const buildProfileNames = await buildProfileNamesFromProjectAsync(projectDir);
 
-  const buildProfileNames = new Set(
-    easJsonAccessor && (await EasJsonUtils.getBuildProfileNamesAsync(easJsonAccessor))
-  );
   const invalidBuildJobs = buildJobs.filter(
     job =>
       !buildProfileNames.has(job.value.params.profile) &&
@@ -165,13 +162,15 @@ function validateWorkflowStructure(parsedYaml: any, workflowJsonSchema: any): vo
   }
 }
 
-function parsedYamlFromWorkflowContents(workflowFileContents: {
-  yamlConfig: string;
-}): Promise<any> {
+export function parsedYamlFromWorkflowContents(workflowFileContents: { yamlConfig: string }): any {
   const parsedYaml = YAML.parse(workflowFileContents.yamlConfig);
   return parsedYaml;
 }
 
+export function workflowContentsFromParsedYaml(parsedYaml: any): string {
+  return YAML.stringify(parsedYaml);
+}
+
 // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
 async function fetchWorkflowSchemaAsync(): Promise<any> {
   // EXPO_TESTING_WORKFLOW_SCHEMA_PATH is used only for testing against a different schema

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

@@ -10,7 +10,6 @@ import { evaluateConfigWithEnvVarsAsync } from '../../build/evaluateConfigWithEn
 import { ensureIosCredentialsForBuildResignAsync } from '../../build/ios/credentials';
 import { prepareCredentialsToResign } from '../../build/ios/prepareJob';
 import { listAndSelectBuildOnAppAsync } from '../../build/queries';
-import { EnvironmentVariableEnvironment } from '../../build/utils/environment';
 import { printBuildResults, printLogsUrls } from '../../build/utils/printBuildInfo';
 import EasCommand from '../../commandUtils/EasCommand';
 import { ExpoGraphqlClient } from '../../commandUtils/context/contextUtils/createGraphqlClient';
@@ -48,7 +47,7 @@ interface BuildResignFlags {
   sourceProfile?: string;
   maybeBuildId?: string;
   wait: boolean;
-  environment?: EnvironmentVariableEnvironment;
+  environment?: string;
 }
 interface RawBuildResignFlags {
   json: boolean;
@@ -60,7 +59,7 @@ interface RawBuildResignFlags {
   'source-profile': string | undefined;
   wait: boolean;
   id: string | undefined;
-  environment: EnvironmentVariableEnvironment | undefined;
+  environment: string | undefined;
 }
 
 export default class BuildResign extends EasCommand {

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

@@ -5,7 +5,6 @@ import chalk from 'chalk';
 import fs from 'node:fs';
 import * as path from 'node:path';
 
-import { EnvironmentVariableEnvironment } from '../../build/utils/environment';
 import { getHostingDeploymentsUrl } from '../../build/utils/url';
 import EasCommand from '../../commandUtils/EasCommand';
 import { EASEnvironmentFlag, EasNonInteractiveAndJsonFlags } from '../../commandUtils/flags';
@@ -45,7 +44,7 @@ interface DeployFlags {
   json: boolean;
   isProduction: boolean;
   aliasName?: string;
-  environment?: EnvironmentVariableEnvironment;
+  environment?: string;
   deploymentIdentifier?: string;
   exportDir: string;
   dryRun: boolean;
@@ -53,7 +52,7 @@ interface DeployFlags {
 
 interface RawDeployFlags {
   'non-interactive': boolean;
-  environment?: EnvironmentVariableEnvironment;
+  environment?: string;
   json: boolean;
   prod: boolean;
   alias?: string;
@@ -138,6 +137,7 @@ export default class WorkerDeploy extends EasCommand {
     logExportedProjectInfo(projectDist);
 
     async function* emitWorkerTarballAsync(params: {
+      routesConfig: WorkerAssets.RoutesConfigEntry | null;
       assetMap: WorkerAssets.AssetMap;
       manifest: WorkerAssets.Manifest;
     }): AsyncGenerator<WorkerAssets.FileEntry> {
@@ -148,6 +148,8 @@ export default class WorkerDeploy extends EasCommand {
         for await (const workerFile of workerFiles) {
           yield [`server/${workerFile.normalizedPath}`, workerFile.data];
         }
+      } else if (projectDist.type === 'static' && params.routesConfig) {
+        yield ['routes.json', JSON.stringify(params.routesConfig)];
       }
     }
 
@@ -284,12 +286,13 @@ export default class WorkerDeploy extends EasCommand {
             manifestResult.conflictingVariableNames.join(' ')
         );
       }
-      assetFiles = await WorkerAssets.collectAssetsAsync(
-        projectDist.type === 'server' ? projectDist.clientPath : projectDist.path,
-        { maxFileSize: MAX_UPLOAD_SIZE }
-      );
+      const assetPath = projectDist.type === 'server' ? projectDist.clientPath : projectDist.path;
+      assetFiles = await WorkerAssets.collectAssetsAsync(assetPath, {
+        maxFileSize: MAX_UPLOAD_SIZE,
+      });
       tarPath = await WorkerAssets.packFilesIterableAsync(
         emitWorkerTarballAsync({
+          routesConfig: await WorkerAssets.getRoutesConfigAsync(assetPath),
           assetMap: WorkerAssets.assetsToAssetsMap(assetFiles),
           manifest: manifestResult.manifest,
         })

packages/eas-cli/src/commands/env/__tests__/EnvCreate.test.ts

@@ -1,7 +1,7 @@
 import { Config } from '@oclif/core';
 
 import { getMockAppFragment } from '../../../__tests__/commands/utils';
-import { EnvironmentVariableEnvironment } from '../../../build/utils/environment';
+import { DefaultEnvironment } from '../../../build/utils/environment';
 import { ExpoGraphqlClient } from '../../../commandUtils/context/contextUtils/createGraphqlClient';
 import { testProjectId } from '../../../credentials/__tests__/fixtures-constants';
 import {
@@ -103,7 +103,7 @@ describe(EnvCreate, () => {
         {
           name: 'VarName',
           value: 'VarValue',
-          environments: [EnvironmentVariableEnvironment.Production],
+          environments: [DefaultEnvironment.Production],
           visibility: EnvironmentVariableVisibility.Secret,
           type: EnvironmentSecretType.String,
         },
@@ -140,7 +140,7 @@ describe(EnvCreate, () => {
         .mockImplementation(async () => [
           {
             id: otherVariableId,
-            environments: [EnvironmentVariableEnvironment.Production],
+            environments: [DefaultEnvironment.Production],
             scope: EnvironmentVariableScope.Project,
           },
         ]);
@@ -168,7 +168,7 @@ describe(EnvCreate, () => {
         id: otherVariableId,
         name: 'VarName',
         value: 'VarValue',
-        environments: [EnvironmentVariableEnvironment.Production],
+        environments: [DefaultEnvironment.Production],
         visibility: EnvironmentVariableVisibility.Secret,
       });
     });
@@ -201,7 +201,7 @@ describe(EnvCreate, () => {
         {
           name: 'VarName',
           value: 'VarValue',
-          environments: [EnvironmentVariableEnvironment.Production],
+          environments: [DefaultEnvironment.Production],
           visibility: EnvironmentVariableVisibility.Public,
           type: EnvironmentSecretType.String,
         },
@@ -236,7 +236,7 @@ describe(EnvCreate, () => {
         .mockImplementation(async () => [
           {
             id: 'otherId',
-            environments: [EnvironmentVariableEnvironment.Production],
+            environments: [DefaultEnvironment.Production],
             scope: EnvironmentVariableScope.Shared,
           },
         ]);
@@ -274,7 +274,7 @@ describe(EnvCreate, () => {
         .mockImplementation(async () => [
           {
             id: otherVariableId,
-            environments: [EnvironmentVariableEnvironment.Production],
+            environments: [DefaultEnvironment.Production],
             scope: EnvironmentVariableScope.Shared,
           },
         ]);
@@ -285,7 +285,7 @@ describe(EnvCreate, () => {
         id: otherVariableId,
         name: 'VarName',
         value: 'VarValue',
-        environments: [EnvironmentVariableEnvironment.Production],
+        environments: [DefaultEnvironment.Production],
         visibility: EnvironmentVariableVisibility.Public,
       });
     });
@@ -320,10 +320,7 @@ describe(EnvCreate, () => {
         {
           name: 'VarName',
           value: 'VarValue',
-          environments: [
-            EnvironmentVariableEnvironment.Production,
-            EnvironmentVariableEnvironment.Development,
-          ],
+          environments: [DefaultEnvironment.Production, DefaultEnvironment.Development],
           visibility: EnvironmentVariableVisibility.Public,
           type: EnvironmentSecretType.String,
         },
@@ -343,7 +340,7 @@ describe(EnvCreate, () => {
       jest
         .mocked(promptVariableEnvironmentAsync)
         // @ts-expect-error
-        .mockImplementation(async () => [EnvironmentVariableEnvironment.Production]);
+        .mockImplementation(async () => [DefaultEnvironment.Production]);
 
       // @ts-expect-error
       jest.spyOn(command, 'getContextAsync').mockReturnValue({
@@ -361,7 +358,7 @@ describe(EnvCreate, () => {
         {
           name: 'VarName',
           value: 'VarValue',
-          environments: [EnvironmentVariableEnvironment.Production],
+          environments: [DefaultEnvironment.Production],
           visibility: EnvironmentVariableVisibility.Public,
           type: EnvironmentSecretType.String,
         },
@@ -369,4 +366,42 @@ describe(EnvCreate, () => {
       );
     });
   });
+
+  it('accepts development environment when using positional argument', async () => {
+    const command = new EnvCreate(
+      [
+        'development',
+        '--name',
+        'TEST_VAR',
+        '--value',
+        'test-value',
+        '--visibility',
+        'plaintext',
+        '--scope',
+        'project',
+        '--non-interactive',
+      ],
+      mockConfig
+    );
+
+    // @ts-expect-error
+    jest.spyOn(command, 'getContextAsync').mockReturnValue({
+      loggedIn: { graphqlClient },
+      projectId: testProjectId,
+    });
+
+    await command.runAsync();
+
+    expect(EnvironmentVariableMutation.createForAppAsync).toHaveBeenCalledWith(
+      graphqlClient,
+      {
+        name: 'TEST_VAR',
+        value: 'test-value',
+        environments: [DefaultEnvironment.Development],
+        visibility: EnvironmentVariableVisibility.Public,
+        type: EnvironmentSecretType.String,
+      },
+      testProjectId
+    );
+  });
 });

packages/eas-cli/src/commands/env/__tests__/EnvDelete.test.ts

@@ -1,7 +1,11 @@
 import { Config } from '@oclif/core';
 
-import { EnvironmentVariableEnvironment } from '../../../build/utils/environment';
-import { EnvironmentVariableScope } from '../../../graphql/generated';
+import { DefaultEnvironment } from '../../../build/utils/environment';
+import {
+  EnvironmentSecretType,
+  EnvironmentVariableScope,
+  EnvironmentVariableVisibility,
+} from '../../../graphql/generated';
 import { EnvironmentVariableMutation } from '../../../graphql/mutations/EnvironmentVariableMutation';
 import { EnvironmentVariablesQuery } from '../../../graphql/queries/EnvironmentVariablesQuery';
 import Log from '../../../log';
@@ -33,7 +37,7 @@ describe(EnvDelete, () => {
         id: variableId,
         name: 'TEST_VARIABLE',
         scope: EnvironmentVariableScope.Project,
-        environments: [EnvironmentVariableEnvironment.Production],
+        environments: [DefaultEnvironment.Production],
       },
     ];
     (EnvironmentVariablesQuery.byAppIdAsync as jest.Mock).mockResolvedValue(mockVariables);
@@ -119,4 +123,40 @@ describe(EnvDelete, () => {
 
     expect(EnvironmentVariableMutation.deleteAsync).not.toHaveBeenCalled();
   });
+
+  it('accepts development environment when using positional argument', async () => {
+    const mockVariable = {
+      id: 'var1',
+      name: 'TEST_VAR_1',
+      value: 'value1',
+      environments: [DefaultEnvironment.Development],
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
+      scope: EnvironmentVariableScope.Project,
+      visibility: EnvironmentVariableVisibility.Public,
+      type: EnvironmentSecretType.String,
+    };
+
+    jest.mocked(EnvironmentVariablesQuery.byAppIdAsync).mockResolvedValueOnce([mockVariable]);
+    jest.mocked(EnvironmentVariableMutation.deleteAsync).mockResolvedValueOnce({ id: 'var1' });
+    jest.spyOn(Log, 'log').mockImplementation(() => {});
+
+    const command = new EnvDelete(
+      ['development', '--variable-name', 'TEST_VAR_1', '--scope', 'project', '--non-interactive'],
+      mockConfig
+    );
+
+    // @ts-expect-error
+    jest.spyOn(command, 'getContextAsync').mockReturnValue({
+      loggedIn: { graphqlClient },
+      projectId,
+    });
+
+    await command.runAsync();
+
+    expect(EnvironmentVariablesQuery.byAppIdAsync).toHaveBeenCalledWith(graphqlClient, {
+      appId: projectId,
+      environment: DefaultEnvironment.Development,
+    });
+  });
 });

packages/eas-cli/src/commands/env/__tests__/EnvExec.test.ts

@@ -0,0 +1,85 @@
+import { Config } from '@oclif/core';
+
+import { DefaultEnvironment } from '../../../build/utils/environment';
+import { ExpoGraphqlClient } from '../../../commandUtils/context/contextUtils/createGraphqlClient';
+import { testProjectId } from '../../../credentials/__tests__/fixtures-constants';
+import {
+  EnvironmentSecretType,
+  EnvironmentVariableScope,
+  EnvironmentVariableVisibility,
+} from '../../../graphql/generated';
+import { EnvironmentVariablesQuery } from '../../../graphql/queries/EnvironmentVariablesQuery';
+import Log from '../../../log';
+import EnvExec from '../exec';
+
+jest.mock('../../../graphql/queries/EnvironmentVariablesQuery');
+jest.mock('../../../log');
+
+describe(EnvExec, () => {
+  const graphqlClient = {} as any as ExpoGraphqlClient;
+  const mockConfig = {} as unknown as Config;
+
+  const mockEnvironmentVariables = [
+    {
+      id: 'var1',
+      name: 'EXPO_PUBLIC_API_URL',
+      value: 'https://api.example.com',
+      environments: [DefaultEnvironment.Development],
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
+      scope: EnvironmentVariableScope.Project,
+      visibility: EnvironmentVariableVisibility.Public,
+      type: EnvironmentSecretType.String,
+    },
+  ];
+
+  beforeEach(() => {
+    jest.resetAllMocks();
+    jest.spyOn(Log, 'log').mockImplementation(() => {});
+
+    // Mock GraphQL query
+    jest
+      .mocked(EnvironmentVariablesQuery.byAppIdWithSensitiveAsync)
+      .mockResolvedValue(mockEnvironmentVariables);
+  });
+
+  it('accepts development environment when using positional argument', async () => {
+    const command = new EnvExec(['development', 'echo $EXPO_PUBLIC_API_URL'], mockConfig);
+
+    // @ts-expect-error
+    jest.spyOn(command, 'getContextAsync').mockReturnValue({
+      loggedIn: { graphqlClient },
+      projectId: testProjectId,
+    });
+
+    await command.runAsync();
+
+    expect(EnvironmentVariablesQuery.byAppIdWithSensitiveAsync).toHaveBeenCalledWith(
+      graphqlClient,
+      {
+        appId: testProjectId,
+        environment: DefaultEnvironment.Development,
+      }
+    );
+  });
+
+  it('accepts custom environment when using positional argument', async () => {
+    const command = new EnvExec(['custom-environment', 'echo $EXPO_PUBLIC_API_URL'], mockConfig);
+
+    // @ts-expect-error
+    jest.spyOn(command, 'getContextAsync').mockReturnValue({
+      loggedIn: { graphqlClient },
+      projectId: testProjectId,
+    });
+
+    await command.runAsync();
+
+    expect(EnvironmentVariablesQuery.byAppIdWithSensitiveAsync).toHaveBeenCalledWith(
+      graphqlClient,
+      {
+        appId: testProjectId,
+        environment: 'custom-environment',
+      }
+    );
+  });
+});

packages/eas-cli/src/commands/env/__tests__/EnvGet.test.ts

@@ -1,6 +1,6 @@
 import { Config } from '@oclif/core';
 
-import { EnvironmentVariableEnvironment } from '../../../build/utils/environment';
+import { DefaultEnvironment } from '../../../build/utils/environment';
 import { ExpoGraphqlClient } from '../../../commandUtils/context/contextUtils/createGraphqlClient';
 import { testProjectId } from '../../../credentials/__tests__/fixtures-constants';
 import {
@@ -27,7 +27,7 @@ describe(EnvGet, () => {
       id: 'var1',
       name: 'TEST_VAR_1',
       value: 'value1',
-      environments: [EnvironmentVariableEnvironment.Production],
+      environments: [DefaultEnvironment.Production],
       createdAt: new Date().toISOString(),
       updatedAt: new Date().toISOString(),
       scope: EnvironmentVariableScope.Project,
@@ -82,7 +82,7 @@ describe(EnvGet, () => {
   it('prompts for variable name and environment if the name is ambigous', async () => {
     jest
       .mocked(promptVariableEnvironmentAsync)
-      .mockResolvedValueOnce(EnvironmentVariableEnvironment.Production);
+      .mockResolvedValueOnce(DefaultEnvironment.Production);
     jest.mocked(promptVariableNameAsync).mockResolvedValueOnce('TEST_VAR_1');
 
     const command = new EnvGet([], mockConfig);
@@ -98,7 +98,7 @@ describe(EnvGet, () => {
         id: 'var2',
         name: 'TEST_VAR_1',
         value: 'value1',
-        environments: [EnvironmentVariableEnvironment.Development],
+        environments: [DefaultEnvironment.Development],
         createdAt: new Date().toISOString(),
         updatedAt: new Date().toISOString(),
         scope: EnvironmentVariableScope.Project,
@@ -111,4 +111,34 @@ describe(EnvGet, () => {
     expect(promptVariableEnvironmentAsync).toHaveBeenCalled();
     expect(promptVariableNameAsync).toHaveBeenCalled();
   });
+
+  it('accepts development environment when using positional argument', async () => {
+    jest
+      .mocked(EnvironmentVariablesQuery.byAppIdWithSensitiveAsync)
+      .mockResolvedValueOnce(mockVariables);
+    jest.spyOn(Log, 'log').mockImplementation(() => {});
+
+    const command = new EnvGet(
+      ['development', '--variable-name', 'TEST_VAR_1', '--scope', 'project'],
+      mockConfig
+    );
+
+    // @ts-expect-error
+    jest.spyOn(command, 'getContextAsync').mockReturnValue({
+      loggedIn: { graphqlClient },
+      projectId: testProjectId,
+    });
+
+    await command.runAsync();
+
+    expect(EnvironmentVariablesQuery.byAppIdWithSensitiveAsync).toHaveBeenCalledWith(
+      graphqlClient,
+      {
+        appId: testProjectId,
+        environment: DefaultEnvironment.Development,
+        filterNames: ['TEST_VAR_1'],
+        includeFileContent: true,
+      }
+    );
+  });
 });

packages/eas-cli/src/commands/env/__tests__/EnvList.test.ts

@@ -1,7 +1,7 @@
 import { Config } from '@oclif/core';
 
 import { getMockAppFragment } from '../../../__tests__/commands/utils';
-import { EnvironmentVariableEnvironment } from '../../../build/utils/environment';
+import { DefaultEnvironment } from '../../../build/utils/environment';
 import { ExpoGraphqlClient } from '../../../commandUtils/context/contextUtils/createGraphqlClient';
 import { testProjectId } from '../../../credentials/__tests__/fixtures-constants';
 import {
@@ -13,10 +13,12 @@ import {
 import { AppQuery } from '../../../graphql/queries/AppQuery';
 import { EnvironmentVariablesQuery } from '../../../graphql/queries/EnvironmentVariablesQuery';
 import Log from '../../../log';
+import { promptVariableEnvironmentAsync } from '../../../utils/prompts';
 import EnvList from '../list';
 
 jest.mock('../../../graphql/queries/EnvironmentVariablesQuery');
 jest.mock('../../../graphql/queries/AppQuery');
+jest.mock('../../../utils/prompts');
 jest.mock('../../../log');
 
 const mockVariables: EnvironmentVariableFragment[] = [
@@ -24,7 +26,7 @@ const mockVariables: EnvironmentVariableFragment[] = [
     id: 'var1',
     name: 'TEST_VAR_1',
     value: 'value1',
-    environments: [EnvironmentVariableEnvironment.Production],
+    environments: [DefaultEnvironment.Production],
     scope: EnvironmentVariableScope.Project,
     visibility: EnvironmentVariableVisibility.Public,
     createdAt: undefined,
@@ -35,7 +37,7 @@ const mockVariables: EnvironmentVariableFragment[] = [
     id: 'var2',
     name: 'TEST_VAR_2',
     value: 'value2',
-    environments: [EnvironmentVariableEnvironment.Development],
+    environments: [DefaultEnvironment.Development],
     scope: EnvironmentVariableScope.Project,
     visibility: EnvironmentVariableVisibility.Public,
     createdAt: undefined,
@@ -51,27 +53,19 @@ describe(EnvList, () => {
   beforeEach(() => {
     jest.clearAllMocks();
     jest.mocked(AppQuery.byIdAsync).mockImplementation(async () => getMockAppFragment());
-  });
-
-  it('lists project environment variables successfully', async () => {
-    jest.mocked(EnvironmentVariablesQuery.byAppIdAsync).mockResolvedValueOnce(mockVariables);
-
-    const command = new EnvList([], mockConfig);
-
-    // @ts-expect-error
-    jest.spyOn(command, 'getContextAsync').mockReturnValue({
-      loggedIn: { graphqlClient },
-      projectId: testProjectId,
-    });
-    await command.runAsync();
-
-    expect(EnvironmentVariablesQuery.byAppIdAsync).toHaveBeenCalledWith(graphqlClient, {
-      appId: testProjectId,
-      environment: undefined,
-      includeFileContent: false,
-    });
-    expect(Log.log).toHaveBeenCalledWith(expect.stringContaining('TEST_VAR_1'));
-    expect(Log.log).toHaveBeenCalledWith(expect.stringContaining('TEST_VAR_2'));
+    (jest.mocked(promptVariableEnvironmentAsync) as jest.MockedFunction<any>).mockImplementation(
+      async (args: any) => {
+        if (args.nonInteractive) {
+          throw new Error(
+            'The `--environment` flag must be set when running in `--non-interactive` mode.'
+          );
+        }
+        if (args.multiple) {
+          return [DefaultEnvironment.Production];
+        }
+        return DefaultEnvironment.Production;
+      }
+    );
   });
 
   it('lists project environment variables in specified environments', async () => {
@@ -88,13 +82,33 @@ describe(EnvList, () => {
 
     expect(EnvironmentVariablesQuery.byAppIdAsync).toHaveBeenCalledWith(graphqlClient, {
       appId: testProjectId,
-      environment: EnvironmentVariableEnvironment.Production,
+      environment: DefaultEnvironment.Production,
       includeFileContent: false,
     });
     expect(Log.log).toHaveBeenCalledWith(expect.stringContaining('TEST_VAR_1'));
     expect(Log.log).toHaveBeenCalledWith(expect.stringContaining('TEST_VAR_2'));
   });
 
+  it('accepts development environment when using positional argument', async () => {
+    jest.mocked(EnvironmentVariablesQuery.byAppIdAsync).mockResolvedValueOnce(mockVariables);
+
+    const command = new EnvList(['development'], mockConfig); // Using positional argument
+
+    // @ts-expect-error
+    jest.spyOn(command, 'getContextAsync').mockReturnValue({
+      loggedIn: { graphqlClient },
+      projectId: testProjectId,
+    });
+
+    await command.runAsync();
+
+    expect(EnvironmentVariablesQuery.byAppIdAsync).toHaveBeenCalledWith(graphqlClient, {
+      appId: testProjectId,
+      environment: DefaultEnvironment.Development,
+      includeFileContent: false,
+    });
+  });
+
   it('lists project environment variables including sensitive values', async () => {
     jest
       .mocked(EnvironmentVariablesQuery.byAppIdWithSensitiveAsync)
@@ -113,7 +127,7 @@ describe(EnvList, () => {
       graphqlClient,
       {
         appId: testProjectId,
-        environment: undefined,
+        environment: DefaultEnvironment.Production,
         includeFileContent: false,
       }
     );
@@ -135,7 +149,7 @@ describe(EnvList, () => {
 
     expect(EnvironmentVariablesQuery.sharedAsync).toHaveBeenCalledWith(graphqlClient, {
       appId: testProjectId,
-      environment: undefined,
+      environment: DefaultEnvironment.Production,
       includeFileContent: false,
     });
     expect(Log.log).toHaveBeenCalledWith(expect.stringContaining('TEST_VAR_1'));
@@ -158,7 +172,7 @@ describe(EnvList, () => {
 
     expect(EnvironmentVariablesQuery.sharedWithSensitiveAsync).toHaveBeenCalledWith(graphqlClient, {
       appId: testProjectId,
-      environment: undefined,
+      environment: DefaultEnvironment.Production,
       includeFileContent: false,
     });
     expect(Log.log).toHaveBeenCalledWith(expect.stringContaining('TEST_VAR_1'));

packages/eas-cli/src/commands/env/__tests__/EnvPull.test.ts

@@ -0,0 +1,388 @@
+import { Config } from '@oclif/core';
+import * as fs from 'fs-extra';
+import path from 'path';
+
+import { DefaultEnvironment } from '../../../build/utils/environment';
+import { ExpoGraphqlClient } from '../../../commandUtils/context/contextUtils/createGraphqlClient';
+import { testProjectId } from '../../../credentials/__tests__/fixtures-constants';
+import {
+  EnvironmentSecretType,
+  EnvironmentVariableScope,
+  EnvironmentVariableVisibility,
+} from '../../../graphql/generated';
+import {
+  EnvironmentVariableWithFileContent,
+  EnvironmentVariablesQuery,
+} from '../../../graphql/queries/EnvironmentVariablesQuery';
+import Log from '../../../log';
+import { confirmAsync } from '../../../prompts';
+import EnvPull from '../pull';
+
+jest.mock('../../../graphql/queries/EnvironmentVariablesQuery');
+jest.mock('../../../prompts');
+jest.mock('fs-extra');
+jest.mock('../../../log');
+
+describe(EnvPull, () => {
+  const graphqlClient = {} as any as ExpoGraphqlClient;
+  const mockConfig = {} as unknown as Config;
+  const testProjectDir = '/test/project';
+  const testTargetPath = '.env.local';
+
+  const mockEnvironmentVariables: EnvironmentVariableWithFileContent[] = [
+    {
+      id: 'var1',
+      name: 'EXPO_PUBLIC_API_URL',
+      value: 'https://api.example.com',
+      environments: [DefaultEnvironment.Development],
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
+      scope: EnvironmentVariableScope.Project,
+      visibility: EnvironmentVariableVisibility.Public,
+      type: EnvironmentSecretType.String,
+    },
+    {
+      id: 'var2',
+      name: 'DATABASE_URL',
+      value: 'postgres://localhost:5432/mydb',
+      environments: [DefaultEnvironment.Development],
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
+      scope: EnvironmentVariableScope.Project,
+      visibility: EnvironmentVariableVisibility.Sensitive,
+      type: EnvironmentSecretType.String,
+    },
+    {
+      id: 'var3',
+      name: 'SECRET_KEY',
+      value: 'super-secret-key',
+      environments: [DefaultEnvironment.Development],
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
+      scope: EnvironmentVariableScope.Project,
+      visibility: EnvironmentVariableVisibility.Secret,
+      type: EnvironmentSecretType.String,
+    },
+    {
+      id: 'var4',
+      name: 'CONFIG_FILE',
+      value: 'base64-encoded-file-content',
+      environments: [DefaultEnvironment.Development],
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
+      scope: EnvironmentVariableScope.Project,
+      visibility: EnvironmentVariableVisibility.Public,
+      type: EnvironmentSecretType.FileBase64,
+      valueWithFileContent: Buffer.from('{"key": "value"}').toString('base64'),
+    },
+  ];
+
+  beforeEach(() => {
+    jest.resetAllMocks();
+    jest.spyOn(Log, 'log').mockImplementation(() => {});
+    jest.spyOn(Log, 'addNewLineIfNone').mockImplementation(() => {});
+
+    // Mock fs-extra methods
+    jest.mocked(fs.exists).mockImplementation(() => Promise.resolve(false));
+    jest.mocked(fs.writeFile).mockImplementation(() => Promise.resolve());
+    jest.mocked(fs.mkdir).mockImplementation(() => Promise.resolve());
+    jest.mocked(fs.readFile).mockImplementation(() => Promise.resolve(''));
+
+    // Mock GraphQL query
+    jest
+      .mocked(EnvironmentVariablesQuery.byAppIdWithSensitiveAsync)
+      .mockResolvedValue(mockEnvironmentVariables);
+  });
+
+  describe('environment validation', () => {
+    it('accepts development environment', async () => {
+      const command = new EnvPull(['development'], mockConfig);
+
+      // @ts-expect-error
+      jest.spyOn(command, 'getContextAsync').mockReturnValue({
+        loggedIn: { graphqlClient },
+        projectId: testProjectId,
+        projectDir: testProjectDir,
+      });
+
+      await command.runAsync();
+
+      expect(EnvironmentVariablesQuery.byAppIdWithSensitiveAsync).toHaveBeenCalledWith(
+        graphqlClient,
+        {
+          appId: testProjectId,
+          environment: 'development',
+          includeFileContent: true,
+        }
+      );
+    });
+
+    it('accepts custom environment', async () => {
+      const command = new EnvPull(['custom-environment'], mockConfig);
+
+      // @ts-expect-error
+      jest.spyOn(command, 'getContextAsync').mockReturnValue({
+        loggedIn: { graphqlClient },
+        projectId: testProjectId,
+        projectDir: testProjectDir,
+      });
+
+      await command.runAsync();
+
+      expect(EnvironmentVariablesQuery.byAppIdWithSensitiveAsync).toHaveBeenCalledWith(
+        graphqlClient,
+        {
+          appId: testProjectId,
+          environment: 'custom-environment',
+          includeFileContent: true,
+        }
+      );
+    });
+  });
+
+  describe('file operations', () => {
+    it('writes environment variables to .env.local file', async () => {
+      const command = new EnvPull(['development'], mockConfig);
+
+      // @ts-expect-error
+      jest.spyOn(command, 'getContextAsync').mockReturnValue({
+        loggedIn: { graphqlClient },
+        projectId: testProjectId,
+        projectDir: testProjectDir,
+      });
+
+      await command.runAsync();
+
+      expect(fs.writeFile).toHaveBeenCalledWith(
+        testTargetPath,
+        expect.stringContaining('# Environment: development')
+      );
+    });
+
+    it('writes correct environment variable content', async () => {
+      const command = new EnvPull(['development'], mockConfig);
+
+      // @ts-expect-error
+      jest.spyOn(command, 'getContextAsync').mockReturnValue({
+        loggedIn: { graphqlClient },
+        projectId: testProjectId,
+        projectDir: testProjectDir,
+      });
+
+      await command.runAsync();
+
+      // Find the call that writes to .env.local (not the file variable)
+      const writeFileCalls = jest.mocked(fs.writeFile).mock.calls;
+      const envFileCall = writeFileCalls.find(call => call[0] === testTargetPath);
+      expect(envFileCall).toBeDefined();
+      const fileContent = envFileCall![1] as string;
+
+      // Check that the file contains the expected content
+      expect(fileContent).toContain('# Environment: development');
+      expect(fileContent).toContain('EXPO_PUBLIC_API_URL=https://api.example.com');
+      expect(fileContent).toContain('DATABASE_URL=postgres://localhost:5432/mydb');
+      expect(fileContent).toContain('# SECRET_KEY=***** (secret)');
+    });
+
+    it('handles file variables correctly', async () => {
+      const command = new EnvPull(['development'], mockConfig);
+
+      // @ts-expect-error
+      jest.spyOn(command, 'getContextAsync').mockReturnValue({
+        loggedIn: { graphqlClient },
+        projectId: testProjectId,
+        projectDir: testProjectDir,
+      });
+
+      await command.runAsync();
+
+      // Should create .eas/.env directory for file variables
+      expect(fs.mkdir).toHaveBeenCalledWith(path.join(testProjectDir, '.eas', '.env'), {
+        recursive: true,
+      });
+
+      // Should write the file content (base64 encoded)
+      expect(fs.writeFile).toHaveBeenCalledWith(
+        path.join(testProjectDir, '.eas', '.env', 'CONFIG_FILE'),
+        Buffer.from('{"key": "value"}').toString('base64'),
+        'base64'
+      );
+
+      // Should include file path in env file
+      const writeFileCalls = jest.mocked(fs.writeFile).mock.calls;
+      const envFileCall = writeFileCalls.find(call => call[0] === testTargetPath);
+      expect(envFileCall).toBeDefined();
+      const fileContent = envFileCall![1] as string;
+      expect(fileContent).toContain('CONFIG_FILE=');
+      expect(fileContent).toContain(path.join(testProjectDir, '.eas', '.env', 'CONFIG_FILE'));
+    });
+
+    it('prompts for overwrite when file exists in interactive mode', async () => {
+      jest.mocked(fs.exists).mockImplementation(() => Promise.resolve(true));
+      jest.mocked(confirmAsync).mockResolvedValue(true);
+
+      const command = new EnvPull(['development'], mockConfig);
+
+      // @ts-expect-error
+      jest.spyOn(command, 'getContextAsync').mockReturnValue({
+        loggedIn: { graphqlClient },
+        projectId: testProjectId,
+        projectDir: testProjectDir,
+      });
+
+      await command.runAsync();
+
+      expect(confirmAsync).toHaveBeenCalledWith({
+        message: `File ${testTargetPath} already exists. Do you want to overwrite it?`,
+      });
+    });
+
+    it('aborts when user declines overwrite', async () => {
+      jest.mocked(fs.exists).mockImplementation(() => Promise.resolve(true));
+      jest.mocked(confirmAsync).mockResolvedValue(false);
+
+      const command = new EnvPull(['development'], mockConfig);
+
+      // @ts-expect-error
+      jest.spyOn(command, 'getContextAsync').mockReturnValue({
+        loggedIn: { graphqlClient },
+        projectId: testProjectId,
+        projectDir: testProjectDir,
+      });
+
+      await expect(command.runAsync()).rejects.toThrow(`File ${testTargetPath} already exists.`);
+    });
+  });
+
+  describe('non-interactive mode', () => {
+    it('works in non-interactive mode', async () => {
+      const command = new EnvPull(['development', '--non-interactive'], mockConfig);
+
+      // @ts-expect-error
+      jest.spyOn(command, 'getContextAsync').mockReturnValue({
+        loggedIn: { graphqlClient },
+        projectId: testProjectId,
+        projectDir: testProjectDir,
+      });
+
+      await command.runAsync();
+
+      expect(EnvironmentVariablesQuery.byAppIdWithSensitiveAsync).toHaveBeenCalledWith(
+        graphqlClient,
+        {
+          appId: testProjectId,
+          environment: 'development',
+          includeFileContent: true,
+        }
+      );
+    });
+
+    it('requires environment in non-interactive mode', async () => {
+      const command = new EnvPull(['--non-interactive'], mockConfig);
+
+      // @ts-expect-error
+      jest.spyOn(command, 'getContextAsync').mockReturnValue({
+        loggedIn: { graphqlClient },
+        projectId: testProjectId,
+        projectDir: testProjectDir,
+      });
+
+      await expect(command.runAsync()).rejects.toThrow(
+        'The `--environment` flag must be set when running in `--non-interactive` mode.'
+      );
+    });
+  });
+
+  describe('custom target path', () => {
+    it('writes to custom path when specified', async () => {
+      const customPath = '.env.custom';
+      const command = new EnvPull(['development', '--path', customPath], mockConfig);
+
+      // @ts-expect-error
+      jest.spyOn(command, 'getContextAsync').mockReturnValue({
+        loggedIn: { graphqlClient },
+        projectId: testProjectId,
+        projectDir: testProjectDir,
+      });
+
+      await command.runAsync();
+
+      expect(fs.writeFile).toHaveBeenCalledWith(
+        customPath,
+        expect.stringContaining('# Environment: development')
+      );
+    });
+  });
+
+  describe('logging', () => {
+    it('logs success message with correct environment', async () => {
+      const command = new EnvPull(['development'], mockConfig);
+
+      // @ts-expect-error
+      jest.spyOn(command, 'getContextAsync').mockReturnValue({
+        loggedIn: { graphqlClient },
+        projectId: testProjectId,
+        projectDir: testProjectDir,
+      });
+
+      await command.runAsync();
+
+      expect(Log.log).toHaveBeenCalledWith(
+        `Pulled plain text and sensitive environment variables from "development" environment to ${testTargetPath}.`
+      );
+    });
+
+    it('logs secret variables that were skipped', async () => {
+      const command = new EnvPull(['development'], mockConfig);
+
+      // @ts-expect-error
+      jest.spyOn(command, 'getContextAsync').mockReturnValue({
+        loggedIn: { graphqlClient },
+        projectId: testProjectId,
+        projectDir: testProjectDir,
+      });
+
+      await command.runAsync();
+
+      expect(Log.log).toHaveBeenCalledWith(
+        expect.stringContaining('The following variables have the secret visibility')
+      );
+      expect(Log.log).toHaveBeenCalledWith(expect.stringContaining('SECRET_KEY'));
+    });
+  });
+
+  describe('existing .env.local file handling', () => {
+    it('preserves existing secret values when they exist', async () => {
+      const existingEnvContent = 'SECRET_KEY=existing-secret-value\nOTHER_VAR=other-value';
+      jest.mocked(fs.exists).mockImplementation(() => Promise.resolve(true));
+      jest.mocked(fs.readFile).mockImplementation(() => Promise.resolve(existingEnvContent));
+      jest.mocked(confirmAsync).mockResolvedValue(true);
+
+      const command = new EnvPull(['development'], mockConfig);
+
+      // @ts-expect-error
+      jest.spyOn(command, 'getContextAsync').mockReturnValue({
+        loggedIn: { graphqlClient },
+        projectId: testProjectId,
+        projectDir: testProjectDir,
+      });
+
+      await command.runAsync();
+
+      // Find the call that writes to .env.local (not the file variable)
+      const writeFileCalls = jest.mocked(fs.writeFile).mock.calls;
+      const envFileCall = writeFileCalls.find(call => call[0] === testTargetPath);
+      expect(envFileCall).toBeDefined();
+      const fileContent = envFileCall![1] as string;
+
+      // Should use existing secret value instead of placeholder
+      expect(fileContent).toContain('SECRET_KEY=existing-secret-value');
+      expect(fileContent).not.toContain('# SECRET_KEY=***** (secret)');
+
+      // Should log that it reused the local value
+      expect(Log.log).toHaveBeenCalledWith(
+        expect.stringContaining('Reused local values for following secrets: SECRET_KEY')
+      );
+    });
+  });
+});

packages/eas-cli/src/commands/env/__tests__/EnvPush.test.ts

@@ -0,0 +1,279 @@
+import { Config } from '@oclif/core';
+import * as fs from 'fs-extra';
+
+import { DefaultEnvironment } from '../../../build/utils/environment';
+import { ExpoGraphqlClient } from '../../../commandUtils/context/contextUtils/createGraphqlClient';
+import { testProjectId } from '../../../credentials/__tests__/fixtures-constants';
+import {
+  EnvironmentSecretType,
+  EnvironmentVariableScope,
+  EnvironmentVariableVisibility,
+} from '../../../graphql/generated';
+import { EnvironmentVariableMutation } from '../../../graphql/mutations/EnvironmentVariableMutation';
+import { EnvironmentVariablesQuery } from '../../../graphql/queries/EnvironmentVariablesQuery';
+import Log from '../../../log';
+import { confirmAsync } from '../../../prompts';
+import EnvPush from '../push';
+
+jest.mock('../../../graphql/mutations/EnvironmentVariableMutation');
+jest.mock('../../../graphql/queries/EnvironmentVariablesQuery');
+jest.mock('fs-extra');
+jest.mock('../../../log');
+jest.mock('../../../prompts');
+
+describe(EnvPush, () => {
+  const graphqlClient = {} as any as ExpoGraphqlClient;
+  const mockConfig = {} as unknown as Config;
+  const testProjectDir = '/test/project';
+  const testEnvPath = '.env.test';
+
+  const mockEnvContent = `EXPO_PUBLIC_API_URL=https://api.example.com
+VARIABLE_NAME=variable value
+SECRET_KEY=super-secret-key`;
+
+  beforeEach(() => {
+    jest.resetAllMocks();
+    jest.spyOn(Log, 'log').mockImplementation(() => {});
+    jest.spyOn(Log, 'warn').mockImplementation(() => {});
+    jest.spyOn(Log, 'error').mockImplementation(() => {});
+
+    // Mock fs-extra methods
+    jest.mocked(fs.exists).mockImplementation(() => Promise.resolve(true));
+    jest.mocked(fs.readFile).mockImplementation(() => Promise.resolve(mockEnvContent));
+
+    // Mock GraphQL queries and mutations
+    jest.mocked(EnvironmentVariablesQuery.byAppIdAsync).mockResolvedValue([]); // No existing variables
+    jest
+      .mocked(EnvironmentVariableMutation.createBulkEnvironmentVariablesForAppAsync)
+      .mockResolvedValue(true);
+    jest.mocked(confirmAsync).mockResolvedValue(true);
+  });
+
+  it('accepts development environment when using positional argument', async () => {
+    jest.mocked(EnvironmentVariablesQuery.byAppIdAsync).mockResolvedValueOnce([]);
+
+    const command = new EnvPush(['development', '--path', testEnvPath], mockConfig);
+
+    // @ts-expect-error
+    jest.spyOn(command, 'getContextAsync').mockReturnValue({
+      loggedIn: { graphqlClient },
+      projectId: testProjectId,
+      projectDir: testProjectDir,
+    });
+
+    await command.runAsync();
+
+    expect(EnvironmentVariablesQuery.byAppIdAsync).toHaveBeenCalledWith(graphqlClient, {
+      appId: testProjectId,
+      environment: DefaultEnvironment.Development,
+      filterNames: ['EXPO_PUBLIC_API_URL', 'VARIABLE_NAME', 'SECRET_KEY'],
+    });
+  });
+
+  it('accepts custom environment', async () => {
+    const command = new EnvPush(['custom-environment', '--path', testEnvPath], mockConfig);
+
+    // @ts-expect-error
+    jest.spyOn(command, 'getContextAsync').mockReturnValue({
+      loggedIn: { graphqlClient },
+      projectId: testProjectId,
+      projectDir: testProjectDir,
+    });
+
+    await command.runAsync();
+
+    expect(EnvironmentVariablesQuery.byAppIdAsync).toHaveBeenCalledWith(graphqlClient, {
+      appId: testProjectId,
+      environment: 'custom-environment',
+      filterNames: ['EXPO_PUBLIC_API_URL', 'VARIABLE_NAME', 'SECRET_KEY'],
+    });
+  });
+
+  describe('--force option', () => {
+    it('automatically overrides existing variables without confirmation when --force is used', async () => {
+      const existingVariable = {
+        id: 'var1',
+        name: 'VARIABLE_NAME',
+        value: 'old variable value',
+        environments: [DefaultEnvironment.Development],
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+        scope: EnvironmentVariableScope.Project,
+        visibility: EnvironmentVariableVisibility.Sensitive,
+        type: EnvironmentSecretType.String,
+      };
+
+      jest.mocked(EnvironmentVariablesQuery.byAppIdAsync).mockResolvedValue([existingVariable]);
+
+      const command = new EnvPush(['development', '--path', testEnvPath, '--force'], mockConfig);
+
+      // @ts-expect-error
+      jest.spyOn(command, 'getContextAsync').mockReturnValue({
+        loggedIn: { graphqlClient },
+        projectId: testProjectId,
+        projectDir: testProjectDir,
+      });
+
+      await command.runAsync();
+
+      // Should not call confirmAsync for existing variables
+      expect(confirmAsync).not.toHaveBeenCalled();
+
+      // Should log that force flag is being used
+      expect(Log.log).toHaveBeenCalledWith(
+        'Using --force flag: automatically overriding existing variables.'
+      );
+
+      // Should call the mutation with overwrite flag
+      expect(
+        EnvironmentVariableMutation.createBulkEnvironmentVariablesForAppAsync
+      ).toHaveBeenCalledWith(
+        graphqlClient,
+        expect.arrayContaining([
+          expect.objectContaining({
+            name: 'VARIABLE_NAME',
+            value: 'variable value',
+            environments: [DefaultEnvironment.Development],
+            overwrite: true,
+          }),
+        ]),
+        testProjectId
+      );
+    });
+
+    it('automatically overrides sensitive variables without confirmation when --force is used', async () => {
+      const existingSensitiveVariable = {
+        id: 'var1',
+        name: 'SECRET_KEY',
+        value: 'old-secret-key',
+        environments: [DefaultEnvironment.Development],
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+        scope: EnvironmentVariableScope.Project,
+        visibility: EnvironmentVariableVisibility.Sensitive,
+        type: EnvironmentSecretType.String,
+      };
+
+      jest
+        .mocked(EnvironmentVariablesQuery.byAppIdAsync)
+        .mockResolvedValue([existingSensitiveVariable]);
+
+      const command = new EnvPush(['development', '--path', testEnvPath, '--force'], mockConfig);
+
+      // @ts-expect-error
+      jest.spyOn(command, 'getContextAsync').mockReturnValue({
+        loggedIn: { graphqlClient },
+        projectId: testProjectId,
+        projectDir: testProjectDir,
+      });
+
+      await command.runAsync();
+
+      // Should not call confirmAsync for sensitive variables
+      expect(confirmAsync).not.toHaveBeenCalled();
+
+      // Should log that force flag is being used for sensitive variables
+      expect(Log.log).toHaveBeenCalledWith(
+        'Using --force flag: automatically overriding sensitive variables.'
+      );
+
+      // Should call the mutation with overwrite flag
+      expect(
+        EnvironmentVariableMutation.createBulkEnvironmentVariablesForAppAsync
+      ).toHaveBeenCalledWith(
+        graphqlClient,
+        expect.arrayContaining([
+          expect.objectContaining({
+            name: 'SECRET_KEY',
+            value: 'super-secret-key',
+            environments: [DefaultEnvironment.Development],
+            overwrite: true,
+          }),
+        ]),
+        testProjectId
+      );
+    });
+
+    it('logs appropriate messages when using --force flag', async () => {
+      const existingVariable = {
+        id: 'var1',
+        name: 'VARIABLE_NAME',
+        value: 'old variable value',
+        environments: [DefaultEnvironment.Development],
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+        scope: EnvironmentVariableScope.Project,
+        visibility: EnvironmentVariableVisibility.Sensitive,
+        type: EnvironmentSecretType.String,
+      };
+
+      jest.mocked(EnvironmentVariablesQuery.byAppIdAsync).mockResolvedValue([existingVariable]);
+
+      const command = new EnvPush(['development', '--path', testEnvPath, '--force'], mockConfig);
+
+      // @ts-expect-error
+      jest.spyOn(command, 'getContextAsync').mockReturnValue({
+        loggedIn: { graphqlClient },
+        projectId: testProjectId,
+        projectDir: testProjectDir,
+      });
+
+      await command.runAsync();
+
+      // Should log both force messages
+      expect(Log.log).toHaveBeenCalledWith(
+        'Using --force flag: automatically overriding existing variables.'
+      );
+      expect(Log.log).toHaveBeenCalledWith(
+        'Using --force flag: automatically overriding sensitive variables.'
+      );
+    });
+
+    it('still prompts for confirmation when --force is not used', async () => {
+      const existingVariable = {
+        id: 'var1',
+        name: 'VARIABLE_NAME',
+        value: 'old variable value',
+        environments: [DefaultEnvironment.Development],
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+        scope: EnvironmentVariableScope.Project,
+        visibility: EnvironmentVariableVisibility.Sensitive,
+        type: EnvironmentSecretType.String,
+      };
+
+      jest.mocked(EnvironmentVariablesQuery.byAppIdAsync).mockResolvedValue([existingVariable]);
+      jest.mocked(confirmAsync).mockResolvedValue(true);
+
+      const command = new EnvPush(['development', '--path', testEnvPath], mockConfig);
+
+      // @ts-expect-error
+      jest.spyOn(command, 'getContextAsync').mockReturnValue({
+        loggedIn: { graphqlClient },
+        projectId: testProjectId,
+        projectDir: testProjectDir,
+      });
+
+      await command.runAsync();
+
+      // Should call confirmAsync for both existing variables and sensitive variables
+      expect(confirmAsync).toHaveBeenCalledTimes(2);
+      expect(confirmAsync).toHaveBeenCalledWith({
+        message:
+          'The VARIABLE_NAME environment variable already exists in development environment. Do you want to override it?',
+      });
+      expect(confirmAsync).toHaveBeenCalledWith({
+        message:
+          'You are about to overwrite sensitive variables.\n- VARIABLE_NAME\n Do you want to continue?',
+      });
+
+      // Should not log force messages
+      expect(Log.log).not.toHaveBeenCalledWith(
+        'Using --force flag: automatically overriding existing variables.'
+      );
+      expect(Log.log).not.toHaveBeenCalledWith(
+        'Using --force flag: automatically overriding sensitive variables.'
+      );
+    });
+  });
+});

packages/eas-cli/src/commands/env/__tests__/EnvUpdate.test.ts

@@ -2,8 +2,9 @@ import { Config } from '@oclif/core';
 import chalk from 'chalk';
 
 import { getMockAppFragment } from '../../../__tests__/commands/utils';
-import { EnvironmentVariableEnvironment } from '../../../build/utils/environment';
+import { DefaultEnvironment } from '../../../build/utils/environment';
 import {
+  EnvironmentSecretType,
   EnvironmentVariableScope,
   EnvironmentVariableVisibility,
 } from '../../../graphql/generated';
@@ -11,12 +12,18 @@ import { EnvironmentVariableMutation } from '../../../graphql/mutations/Environm
 import { AppQuery } from '../../../graphql/queries/AppQuery';
 import { EnvironmentVariablesQuery } from '../../../graphql/queries/EnvironmentVariablesQuery';
 import Log from '../../../log';
-import { promptAsync, toggleConfirmAsync } from '../../../prompts';
+import { promptAsync, selectAsync, toggleConfirmAsync } from '../../../prompts';
+import {
+  parseVisibility,
+  promptVariableEnvironmentAsync,
+  promptVariableVisibilityAsync,
+} from '../../../utils/prompts';
 import EnvUpdate from '../update';
 
 jest.mock('../../../graphql/queries/EnvironmentVariablesQuery');
 jest.mock('../../../graphql/mutations/EnvironmentVariableMutation');
 jest.mock('../../../prompts');
+jest.mock('../../../utils/prompts');
 jest.mock('../../../graphql/queries/AppQuery');
 jest.mock('../../../log');
 
@@ -33,6 +40,41 @@ describe(EnvUpdate, () => {
   beforeEach(() => {
     jest.resetAllMocks();
     jest.mocked(AppQuery.byIdAsync).mockImplementation(async () => getMockAppFragment());
+    (jest.mocked(promptVariableEnvironmentAsync) as jest.MockedFunction<any>).mockImplementation(
+      async (args: any) => {
+        if (args.nonInteractive) {
+          throw new Error(
+            'The `--environment` flag must be set when running in `--non-interactive` mode.'
+          );
+        }
+        if (args.multiple) {
+          return ['production'];
+        }
+        return 'production';
+      }
+    );
+    (jest.mocked(promptVariableVisibilityAsync) as jest.MockedFunction<any>).mockResolvedValue(
+      EnvironmentVariableVisibility.Public
+    );
+    (jest.mocked(parseVisibility) as jest.MockedFunction<any>).mockImplementation(
+      (visibility: string) => {
+        switch (visibility) {
+          case 'plaintext':
+            return EnvironmentVariableVisibility.Public;
+          case 'sensitive':
+            return EnvironmentVariableVisibility.Sensitive;
+          case 'secret':
+            return EnvironmentVariableVisibility.Secret;
+          default:
+            throw new Error(`Invalid visibility: ${visibility}`);
+        }
+      }
+    );
+    (jest.mocked(selectAsync) as jest.MockedFunction<any>).mockResolvedValue({
+      id: variableId,
+      name: 'TEST_VARIABLE',
+      scope: EnvironmentVariableScope.Project,
+    });
   });
 
   it('updates a project variable by selected name in non-interactive mode', async () => {
@@ -41,7 +83,7 @@ describe(EnvUpdate, () => {
         id: variableId,
         name: 'TEST_VARIABLE',
         scope: EnvironmentVariableScope.Project,
-        environments: [EnvironmentVariableEnvironment.Development],
+        environments: [DefaultEnvironment.Development],
       },
     ];
     (EnvironmentVariablesQuery.byAppIdAsync as jest.Mock).mockResolvedValue(mockVariables);
@@ -73,7 +115,7 @@ describe(EnvUpdate, () => {
       id: variableId,
       name: 'NEW_VARIABLE',
       value: 'new-value',
-      environments: [EnvironmentVariableEnvironment.Production],
+      environments: [DefaultEnvironment.Production],
       visibility: EnvironmentVariableVisibility.Public,
     });
     expect(Log.withTick).toHaveBeenCalledWith(
@@ -87,7 +129,7 @@ describe(EnvUpdate, () => {
         id: variableId,
         name: 'TEST_VARIABLE',
         scope: EnvironmentVariableScope.Shared,
-        environments: [EnvironmentVariableEnvironment.Development],
+        environments: [DefaultEnvironment.Development],
       },
     ];
     (EnvironmentVariablesQuery.sharedAsync as jest.Mock).mockResolvedValue(mockVariables);
@@ -119,7 +161,7 @@ describe(EnvUpdate, () => {
       id: variableId,
       name: 'NEW_VARIABLE',
       value: 'new-value',
-      environments: [EnvironmentVariableEnvironment.Production],
+      environments: [DefaultEnvironment.Production],
     });
     expect(Log.withTick).toHaveBeenCalledWith(
       `Updated variable ${chalk.bold('TEST_VARIABLE')} on account testuser.`
@@ -129,6 +171,7 @@ describe(EnvUpdate, () => {
   it('prompts for variable selection when selected name is not provided', async () => {
     const mockVariables = [
       { id: variableId, name: 'TEST_VARIABLE', scope: EnvironmentVariableScope.Project },
+      { id: '2', name: 'ANOTHER_VARIABLE', scope: EnvironmentVariableScope.Project },
     ];
     (EnvironmentVariablesQuery.byAppIdAsync as jest.Mock).mockResolvedValue(mockVariables);
     (EnvironmentVariableMutation.updateAsync as jest.Mock).mockResolvedValue(mockVariables[0]);
@@ -140,7 +183,7 @@ describe(EnvUpdate, () => {
     jest.spyOn(command, 'getContextAsync').mockReturnValue(mockContext);
     await command.runAsync();
 
-    expect(promptAsync).toHaveBeenCalled();
+    expect(selectAsync).toHaveBeenCalled();
     expect(EnvironmentVariableMutation.updateAsync).toHaveBeenCalledWith(
       graphqlClient,
       expect.objectContaining({ id: variableId })
@@ -162,4 +205,50 @@ describe(EnvUpdate, () => {
       'Variable with name NON_EXISTENT_VARIABLE  does not exist on project @testuser/testpp.'
     );
   });
+
+  it('accepts development environment when using positional argument', async () => {
+    const mockVariable = {
+      id: 'var1',
+      name: 'TEST_VAR_1',
+      value: 'value1',
+      environments: [DefaultEnvironment.Development],
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
+      scope: EnvironmentVariableScope.Project,
+      visibility: EnvironmentVariableVisibility.Public,
+      type: EnvironmentSecretType.String,
+    };
+
+    jest.mocked(EnvironmentVariablesQuery.byAppIdAsync).mockResolvedValueOnce([mockVariable]);
+    jest.mocked(EnvironmentVariableMutation.updateAsync).mockResolvedValueOnce(mockVariable);
+    jest.spyOn(Log, 'log').mockImplementation(() => {});
+
+    const command = new EnvUpdate(
+      [
+        'development',
+        '--variable-name',
+        'TEST_VAR_1',
+        '--value',
+        'new-value',
+        '--scope',
+        'project',
+        '--non-interactive',
+      ],
+      mockConfig
+    );
+
+    // @ts-expect-error
+    jest.spyOn(command, 'getContextAsync').mockReturnValue({
+      loggedIn: { graphqlClient },
+      projectId,
+    });
+
+    await command.runAsync();
+
+    expect(EnvironmentVariablesQuery.byAppIdAsync).toHaveBeenCalledWith(graphqlClient, {
+      appId: projectId,
+      environment: DefaultEnvironment.Development,
+      filterNames: ['TEST_VAR_1'],
+    });
+  });
 });

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

@@ -3,8 +3,8 @@ import chalk from 'chalk';
 import fs from 'fs-extra';
 import path from 'path';
 
-import { EnvironmentVariableEnvironment } from '../../build/utils/environment';
 import EasCommand from '../../commandUtils/EasCommand';
+import { ExpoGraphqlClient } from '../../commandUtils/context/contextUtils/createGraphqlClient';
 import {
   EASEnvironmentVariableScopeFlag,
   EASEnvironmentVariableScopeFlagValue,
@@ -33,7 +33,6 @@ import {
   promptVariableValueAsync,
   promptVariableVisibilityAsync,
 } from '../../utils/prompts';
-import { isEnvironment } from '../../utils/variableUtils';
 
 interface RawCreateFlags {
   name?: string;
@@ -42,7 +41,7 @@ interface RawCreateFlags {
   type?: 'string' | 'file';
   visibility?: 'plaintext' | 'sensitive' | 'secret';
   scope: EASEnvironmentVariableScopeFlagValue;
-  environment?: EnvironmentVariableEnvironment[];
+  environment?: string[];
   'non-interactive': boolean;
 }
 
@@ -53,7 +52,7 @@ interface CreateFlags {
   type?: 'string' | 'file';
   visibility?: 'plaintext' | 'sensitive' | 'secret';
   scope: EnvironmentVariableScope;
-  environment?: EnvironmentVariableEnvironment[];
+  environment?: string[];
   'non-interactive': boolean;
 }
 
@@ -64,7 +63,7 @@ export default class EnvCreate extends EasCommand {
     {
       name: 'environment',
       description:
-        "Environment to create the variable in. One of 'production', 'preview', or 'development'.",
+        "Environment to create the variable in. Default environments are 'production', 'preview', and 'development'.",
       required: false,
     },
   ];
@@ -101,6 +100,13 @@ export default class EnvCreate extends EasCommand {
 
     const validatedFlags = this.sanitizeFlags(flags);
 
+    const {
+      projectId,
+      loggedIn: { graphqlClient },
+    } = await this.getContextAsync(EnvCreate, {
+      nonInteractive: validatedFlags['non-interactive'],
+    });
+
     const {
       name,
       value,
@@ -111,14 +117,7 @@ export default class EnvCreate extends EasCommand {
       force,
       type,
       fileName,
-    } = await this.promptForMissingFlagsAsync(validatedFlags, args);
-
-    const {
-      projectId,
-      loggedIn: { graphqlClient },
-    } = await this.getContextAsync(EnvCreate, {
-      nonInteractive,
-    });
+    } = await this.promptForMissingFlagsAsync(validatedFlags, args, { graphqlClient, projectId });
 
     const [projectDisplayName, ownerAccount] = await Promise.all([
       getDisplayNameForProjectIdAsync(graphqlClient, projectId),
@@ -272,7 +271,8 @@ export default class EnvCreate extends EasCommand {
       type,
       ...rest
     }: CreateFlags,
-    { environment }: { environment?: string }
+    { environment }: { environment?: string },
+    { graphqlClient, projectId }: { graphqlClient: ExpoGraphqlClient; projectId: string }
   ): Promise<
     Required<
       Omit<CreateFlags, 'type' | 'visibility'> & {
@@ -323,18 +323,16 @@ export default class EnvCreate extends EasCommand {
 
     value = environmentFilePath ? await fs.readFile(environmentFilePath, 'base64') : value;
 
-    if (environment && !isEnvironment(environment.toUpperCase())) {
-      throw new Error("Invalid environment. Use one of 'production', 'preview', or 'development'.");
-    }
-
-    let newEnvironments = environments
-      ? environments
-      : environment
-        ? [environment.toUpperCase() as EnvironmentVariableEnvironment]
-        : undefined;
+    let newEnvironments = environments ? environments : environment ? [environment] : undefined;
 
     if (!newEnvironments) {
-      newEnvironments = await promptVariableEnvironmentAsync({ nonInteractive, multiple: true });
+      newEnvironments = await promptVariableEnvironmentAsync({
+        nonInteractive,
+        multiple: true,
+        canEnterCustomEnvironment: true,
+        graphqlClient,
+        projectId,
+      });
 
       if (!newEnvironments || newEnvironments.length === 0) {
         throw new Error('No environments selected');

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

@@ -2,7 +2,6 @@ import { Flags } from '@oclif/core';
 import assert from 'assert';
 import chalk from 'chalk';
 
-import { EnvironmentVariableEnvironment } from '../../build/utils/environment';
 import EasCommand from '../../commandUtils/EasCommand';
 import {
   EASEnvironmentVariableScopeFlag,
@@ -15,18 +14,18 @@ import { EnvironmentVariableMutation } from '../../graphql/mutations/Environment
 import { EnvironmentVariablesQuery } from '../../graphql/queries/EnvironmentVariablesQuery';
 import Log from '../../log';
 import { promptAsync, toggleConfirmAsync } from '../../prompts';
-import { formatVariableName, isEnvironment } from '../../utils/variableUtils';
+import { formatVariableName } from '../../utils/variableUtils';
 
 interface DeleteFlags {
   'variable-name'?: string;
-  'variable-environment'?: EnvironmentVariableEnvironment;
+  'variable-environment'?: string;
   'non-interactive': boolean;
   scope: EnvironmentVariableScope;
 }
 
 interface RawDeleteFlags {
   'variable-name'?: string;
-  'variable-environment'?: EnvironmentVariableEnvironment;
+  'variable-environment'?: string;
   'non-interactive': boolean;
   scope: EASEnvironmentVariableScopeFlagValue;
 }
@@ -38,7 +37,7 @@ export default class EnvDelete extends EasCommand {
     'variable-name': Flags.string({
       description: 'Name of the variable to delete',
     }),
-    'variable-environment': Flags.enum<EnvironmentVariableEnvironment>({
+    'variable-environment': Flags.string({
       ...EasEnvironmentFlagParameters,
       description: 'Current environment of the variable to delete',
     }),
@@ -50,7 +49,7 @@ export default class EnvDelete extends EasCommand {
     {
       name: 'environment',
       description:
-        "Current environment of the variable to delete. One of 'production', 'preview', or 'development'.",
+        "Current environment of the variable to delete. Default environments are 'production', 'preview', and 'development'.",
       required: false,
     },
   ];
@@ -166,13 +165,6 @@ export default class EnvDelete extends EasCommand {
         : EnvironmentVariableScope.Project;
 
     if (environment) {
-      environment = environment.toUpperCase();
-
-      if (!isEnvironment(environment)) {
-        throw new Error(
-          "Invalid environment. Use one of 'production', 'preview', or 'development'."
-        );
-      }
       return { ...flags, 'variable-environment': environment, scope };
     }
 

packages/eas-cli/src/commands/env/exec.ts

@@ -1,24 +1,22 @@
 import spawnAsync from '@expo/spawn-async';
 import chalk from 'chalk';
 
-import { EnvironmentVariableEnvironment } from '../../build/utils/environment';
 import EasCommand from '../../commandUtils/EasCommand';
 import { ExpoGraphqlClient } from '../../commandUtils/context/contextUtils/createGraphqlClient';
 import { EASNonInteractiveFlag } from '../../commandUtils/flags';
 import { EnvironmentVariablesQuery } from '../../graphql/queries/EnvironmentVariablesQuery';
 import Log from '../../log';
 import { promptVariableEnvironmentAsync } from '../../utils/prompts';
-import { isEnvironment } from '../../utils/variableUtils';
 
 type ParsedFlags =
   | {
       nonInteractive: true;
-      environment: EnvironmentVariableEnvironment;
+      environment: string;
       command: string;
     }
   | {
       nonInteractive: false;
-      environment?: EnvironmentVariableEnvironment;
+      environment?: string;
       command: string;
     };
 
@@ -44,7 +42,7 @@ export default class EnvExec extends EasCommand {
       name: 'environment',
       required: true,
       description:
-        "Environment to execute the command in. One of 'production', 'preview', or 'development'.",
+        "Environment to execute the command in. Default environments are 'production', 'preview', and 'development'.",
     },
     {
       name: 'bash_command',
@@ -70,7 +68,11 @@ export default class EnvExec extends EasCommand {
 
     const environment =
       parsedFlags.environment ??
-      (await promptVariableEnvironmentAsync({ nonInteractive: parsedFlags.nonInteractive }));
+      (await promptVariableEnvironmentAsync({
+        nonInteractive: parsedFlags.nonInteractive,
+        graphqlClient,
+        projectId,
+      }));
     const environmentVariables = await this.loadEnvironmentVariablesAsync({
       graphqlClient,
       projectId,
@@ -101,12 +103,6 @@ export default class EnvExec extends EasCommand {
       );
     }
 
-    environment = environment?.toUpperCase();
-
-    if (!isEnvironment(environment)) {
-      throw new Error("Invalid environment. Use one of 'production', 'preview', or 'development'.");
-    }
-
     const firstChar = bash_command[0];
     const lastChar = bash_command[bash_command.length - 1];
     const cleanCommand =
@@ -198,7 +194,7 @@ export default class EnvExec extends EasCommand {
   }: {
     graphqlClient: ExpoGraphqlClient;
     projectId: string;
-    environment: EnvironmentVariableEnvironment;
+    environment: string;
     nonInteractive: boolean;
   }): Promise<Record<string, string>> {
     const environmentVariablesQueryResult =

packages/eas-cli/src/commands/env/get.ts

@@ -1,7 +1,6 @@
 import { Flags } from '@oclif/core';
 import chalk from 'chalk';
 
-import { EnvironmentVariableEnvironment } from '../../build/utils/environment';
 import EasCommand from '../../commandUtils/EasCommand';
 import { ExpoGraphqlClient } from '../../commandUtils/context/contextUtils/createGraphqlClient';
 import {
@@ -19,11 +18,11 @@ import {
 import { EnvironmentVariablesQuery } from '../../graphql/queries/EnvironmentVariablesQuery';
 import Log from '../../log';
 import { promptVariableEnvironmentAsync, promptVariableNameAsync } from '../../utils/prompts';
-import { formatVariable, formatVariableValue, isEnvironment } from '../../utils/variableUtils';
+import { formatVariable, formatVariableValue } from '../../utils/variableUtils';
 
 interface RawGetFlags {
   'variable-name'?: string;
-  'variable-environment'?: EnvironmentVariableEnvironment;
+  'variable-environment'?: string;
   'non-interactive': boolean;
   format?: string;
   scope: EASEnvironmentVariableScopeFlagValue;
@@ -31,7 +30,7 @@ interface RawGetFlags {
 
 interface GetFlags {
   'variable-name'?: string;
-  'variable-environment'?: EnvironmentVariableEnvironment;
+  'variable-environment'?: string;
   'non-interactive': boolean;
   format?: string;
   scope: EnvironmentVariableScope;
@@ -49,7 +48,7 @@ export default class EnvGet extends EasCommand {
     {
       name: 'environment',
       description:
-        "Current environment of the variable. One of 'production', 'preview', or 'development'.",
+        "Current environment of the variable. Default environments are 'production', 'preview', and 'development'.",
       required: false,
     },
   ];
@@ -58,7 +57,7 @@ export default class EnvGet extends EasCommand {
     'variable-name': Flags.string({
       description: 'Name of the variable',
     }),
-    'variable-environment': Flags.enum<EnvironmentVariableEnvironment>({
+    'variable-environment': Flags.string({
       ...EasEnvironmentFlagParameters,
       description: 'Current environment of the variable',
     }),
@@ -93,6 +92,8 @@ export default class EnvGet extends EasCommand {
       environment = await promptVariableEnvironmentAsync({
         nonInteractive,
         multiple: false,
+        graphqlClient,
+        projectId,
       });
     }
 
@@ -156,12 +157,6 @@ export default class EnvGet extends EasCommand {
         ? EnvironmentVariableScope.Shared
         : EnvironmentVariableScope.Project;
     if (environment) {
-      environment = environment.toUpperCase();
-      if (!isEnvironment(environment)) {
-        throw new Error(
-          "Invalid environment. Use one of 'production', 'preview', or 'development'."
-        );
-      }
       return {
         ...flags,
         'variable-environment': environment,
@@ -177,7 +172,7 @@ async function getVariablesAsync(
   scope: string,
   projectId: string,
   name: string | undefined,
-  environment: EnvironmentVariableEnvironment | undefined
+  environment: string | undefined
 ): Promise<EnvironmentVariableFragment[]> {
   if (!name) {
     throw new Error(

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

@@ -1,7 +1,6 @@
 import { Flags } from '@oclif/core';
 import chalk from 'chalk';
 
-import { EnvironmentVariableEnvironment } from '../../build/utils/environment';
 import EasCommand from '../../commandUtils/EasCommand';
 import { ExpoGraphqlClient } from '../../commandUtils/context/contextUtils/createGraphqlClient';
 import {
@@ -20,7 +19,6 @@ import { promptVariableEnvironmentAsync } from '../../utils/prompts';
 import {
   formatVariable,
   formatVariableValue,
-  isEnvironment,
   performForEnvironmentsAsync,
 } from '../../utils/variableUtils';
 
@@ -36,7 +34,7 @@ async function getVariablesForScopeAsync(
     scope: EnvironmentVariableScope;
     includingSensitive: boolean;
     includeFileContent: boolean;
-    environment?: EnvironmentVariableEnvironment;
+    environment?: string;
     projectId: string;
   }
 ): Promise<EnvironmentVariableWithFileContent[]> {
@@ -71,7 +69,7 @@ async function getVariablesForScopeAsync(
 interface RawListFlags {
   scope: EASEnvironmentVariableScopeFlagValue;
   format: string;
-  environment: EnvironmentVariableEnvironment[] | undefined;
+  environment: string[] | undefined;
   'include-sensitive': boolean;
   'include-file-content': boolean;
   'non-interactive'?: boolean;
@@ -80,7 +78,7 @@ interface RawListFlags {
 interface ListFlags {
   scope: EnvironmentVariableScope;
   format: string;
-  environment: EnvironmentVariableEnvironment[] | undefined;
+  environment: string[] | undefined;
   'include-sensitive': boolean;
   'include-file-content': boolean;
   'non-interactive': boolean;
@@ -112,7 +110,7 @@ export default class EnvList extends EasCommand {
     {
       name: 'environment',
       description:
-        "Environment to list the variables from. One of 'production', 'preview', or 'development'.",
+        "Environment to list the variables from. Default environments are 'production', 'preview', and 'development'.",
       required: false,
     },
   ];
@@ -137,7 +135,12 @@ export default class EnvList extends EasCommand {
     });
 
     if (!environments) {
-      environments = await promptVariableEnvironmentAsync({ nonInteractive, multiple: true });
+      environments = await promptVariableEnvironmentAsync({
+        nonInteractive,
+        multiple: true,
+        graphqlClient,
+        projectId,
+      });
     }
 
     await performForEnvironmentsAsync(environments, async environment => {
@@ -180,14 +183,10 @@ export default class EnvList extends EasCommand {
     flags: RawListFlags,
     { environment }: { environment?: string }
   ): ListFlags {
-    if (environment && !isEnvironment(environment.toUpperCase())) {
-      throw new Error("Invalid environment. Use one of 'production', 'preview', or 'development'.");
-    }
-
     const environments = flags.environment
       ? flags.environment
       : environment
-        ? [environment.toUpperCase() as EnvironmentVariableEnvironment]
+        ? [environment]
         : undefined;
 
     return {

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

@@ -13,7 +13,6 @@ import {
 import Log from '../../log';
 import { confirmAsync } from '../../prompts';
 import { promptVariableEnvironmentAsync } from '../../utils/prompts';
-import { isEnvironment } from '../../utils/variableUtils';
 
 export default class EnvPull extends EasCommand {
   static override description =
@@ -29,7 +28,7 @@ export default class EnvPull extends EasCommand {
     {
       name: 'environment',
       description:
-        "Environment to pull variables from. One of 'production', 'preview', or 'development'.",
+        "Environment to pull variables from. Default environments are 'production', 'preview', and 'development'.",
       required: false,
     },
   ];
@@ -49,15 +48,7 @@ export default class EnvPull extends EasCommand {
       flags: { environment: flagEnvironment, path: targetPath, 'non-interactive': nonInteractive },
     } = await this.parse(EnvPull);
 
-    let environment = flagEnvironment?.toUpperCase() ?? argEnvironment?.toUpperCase();
-
-    if (!environment) {
-      environment = await promptVariableEnvironmentAsync({ nonInteractive });
-    }
-
-    if (!isEnvironment(environment)) {
-      throw new Error("Invalid environment. Use one of 'production', 'preview', or 'development'.");
-    }
+    let environment = flagEnvironment?.toLowerCase() ?? argEnvironment?.toLowerCase();
 
     const {
       projectId,
@@ -67,6 +58,14 @@ export default class EnvPull extends EasCommand {
       nonInteractive,
     });
 
+    if (!environment) {
+      environment = await promptVariableEnvironmentAsync({
+        nonInteractive,
+        graphqlClient,
+        projectId,
+      });
+    }
+
     targetPath = targetPath ?? '.env.local';
 
     const environmentVariables = await EnvironmentVariablesQuery.byAppIdWithSensitiveAsync(

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

@@ -3,7 +3,6 @@ import dotenv from 'dotenv';
 import fs from 'fs-extra';
 import path from 'path';
 
-import { EnvironmentVariableEnvironment } from '../../build/utils/environment';
 import EasCommand from '../../commandUtils/EasCommand';
 import { EASMultiEnvironmentFlag } from '../../commandUtils/flags';
 import {
@@ -17,7 +16,6 @@ import { EnvironmentVariablesQuery } from '../../graphql/queries/EnvironmentVari
 import Log from '../../log';
 import { confirmAsync, promptAsync } from '../../prompts';
 import { promptVariableEnvironmentAsync } from '../../utils/prompts';
-import { isEnvironment } from '../../utils/variableUtils';
 
 export default class EnvPush extends EasCommand {
   static override description =
@@ -34,13 +32,17 @@ export default class EnvPush extends EasCommand {
       description: 'Path to the input `.env` file',
       default: '.env.local',
     }),
+    force: Flags.boolean({
+      description: 'Skip confirmation and automatically override existing variables',
+      default: false,
+    }),
   };
 
   static override args = [
     {
       name: 'environment',
       description:
-        "Environment to push variables to. One of 'production', 'preview', or 'development'.",
+        "Environment to push variables to. Default environments are 'production', 'preview', and 'development'.",
       required: false,
     },
   ];
@@ -48,7 +50,7 @@ export default class EnvPush extends EasCommand {
   async runAsync(): Promise<void> {
     const { args, flags } = await this.parse(EnvPush);
 
-    let { environment: environments, path: envPath } = this.parseFlagsAndArgs(flags, args);
+    let { environment: environments, path: envPath, force } = this.parseFlagsAndArgs(flags, args);
 
     const {
       projectId,
@@ -61,6 +63,9 @@ export default class EnvPush extends EasCommand {
       environments = await promptVariableEnvironmentAsync({
         nonInteractive: false,
         multiple: true,
+        canEnterCustomEnvironment: true,
+        graphqlClient,
+        projectId,
       });
     }
 
@@ -114,40 +119,46 @@ export default class EnvPush extends EasCommand {
         Log.warn(`Some variables already exist in the ${displayedEnvironment} environment.`);
         const variableNames = existingDifferentVariables.map(variable => variable.name);
 
-        const confirmationMessage =
-          variableNames.length > 1
-            ? `The ${variableNames.join(
-                ', '
-              )} environment variables already exist in ${displayedEnvironment} environment. Do you want to override them all?`
-            : `The ${variableNames[0]} environment variable already exists in ${displayedEnvironment} environment. Do you want to override it?`;
-
-        const confirm = await confirmAsync({
-          message: confirmationMessage,
-        });
-
         let variablesToOverwrite: string[] = [];
 
-        if (!confirm && existingDifferentVariables.length === 0) {
-          throw new Error('No new variables to push.');
-        }
-
-        if (confirm) {
+        if (force) {
+          // When --force is used, automatically override all existing variables
+          Log.log('Using --force flag: automatically overriding existing variables.');
           variablesToOverwrite = existingDifferentVariables.map(variable => variable.name);
         } else {
-          const promptResult = await promptAsync({
-            type: 'multiselect',
-            name: 'variablesToOverwrite',
-            message: 'Select variables to overwrite:',
-            // @ts-expect-error property missing from `@types/prompts`
-            optionsPerPage: 20,
-            choices: existingDifferentVariables.map(variable => ({
-              title: `${variable.name}: ${updateVariables[variable.name].value} (was ${
-                variable.value ?? '(secret)'
-              })`,
-              value: variable.name,
-            })),
+          const confirmationMessage =
+            variableNames.length > 1
+              ? `The ${variableNames.join(
+                  ', '
+                )} environment variables already exist in ${displayedEnvironment} environment. Do you want to override them all?`
+              : `The ${variableNames[0]} environment variable already exists in ${displayedEnvironment} environment. Do you want to override it?`;
+
+          const confirm = await confirmAsync({
+            message: confirmationMessage,
           });
-          variablesToOverwrite = promptResult.variablesToOverwrite;
+
+          if (!confirm && existingDifferentVariables.length === 0) {
+            throw new Error('No new variables to push.');
+          }
+
+          if (confirm) {
+            variablesToOverwrite = existingDifferentVariables.map(variable => variable.name);
+          } else {
+            const promptResult = await promptAsync({
+              type: 'multiselect',
+              name: 'variablesToOverwrite',
+              message: 'Select variables to overwrite:',
+              // @ts-expect-error property missing from `@types/prompts`
+              optionsPerPage: 20,
+              choices: existingDifferentVariables.map(variable => ({
+                title: `${variable.name}: ${updateVariables[variable.name].value} (was ${
+                  variable.value ?? '(secret)'
+                })`,
+                value: variable.name,
+              })),
+            });
+            variablesToOverwrite = promptResult.variablesToOverwrite;
+          }
         }
 
         for (const existingVariable of existingVariables) {
@@ -165,7 +176,7 @@ export default class EnvPush extends EasCommand {
         variable => variable.visibility !== EnvironmentVariableVisibility.Public
       );
 
-      if (existingSensitiveVariables.length > 0) {
+      if (existingSensitiveVariables.length > 0 && !force) {
         const existingSensitiveVariablesNames = existingSensitiveVariables.map(
           variable => `- ${variable.name}`
         );
@@ -177,6 +188,8 @@ export default class EnvPush extends EasCommand {
         if (!confirm) {
           throw new Error('Aborting...');
         }
+      } else if (existingSensitiveVariables.length > 0 && force) {
+        Log.log('Using --force flag: automatically overriding sensitive variables.');
       }
     }
 
@@ -196,16 +209,14 @@ export default class EnvPush extends EasCommand {
   }
 
   parseFlagsAndArgs(
-    flags: { path: string; environment: EnvironmentVariableEnvironment[] | undefined },
+    flags: {
+      path: string;
+      environment: string[] | undefined;
+      force: boolean;
+    },
     { environment }: Record<string, string>
-  ): { environment?: EnvironmentVariableEnvironment[]; path: string } {
-    if (environment && !isEnvironment(environment.toUpperCase())) {
-      throw new Error("Invalid environment. Use one of 'production', 'preview', or 'development'.");
-    }
-
-    const environments =
-      flags.environment ??
-      (environment ? [environment.toUpperCase() as EnvironmentVariableEnvironment] : undefined);
+  ): { environment?: string[]; path: string; force: boolean } {
+    const environments = flags.environment ?? (environment ? [environment] : undefined);
 
     return {
       ...flags,
@@ -215,13 +226,8 @@ export default class EnvPush extends EasCommand {
 
   private async parseEnvFileAsync(
     envPath: string,
-    environments: EnvironmentVariableEnvironment[]
-  ): Promise<
-    Record<
-      string,
-      CreateEnvironmentVariableInput & { environments: EnvironmentVariableEnvironment[] }
-    >
-  > {
+    environments: string[]
+  ): Promise<Record<string, CreateEnvironmentVariableInput & { environments: string[] }>> {
     if (!(await fs.exists(envPath))) {
       throw new Error(`File ${envPath} does not exist.`);
     }

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

@@ -4,8 +4,8 @@ import chalk from 'chalk';
 import fs from 'fs-extra';
 import path from 'path';
 
-import { EnvironmentVariableEnvironment } from '../../build/utils/environment';
 import EasCommand from '../../commandUtils/EasCommand';
+import { ExpoGraphqlClient } from '../../commandUtils/context/contextUtils/createGraphqlClient';
 import {
   EASEnvironmentVariableScopeFlag,
   EASEnvironmentVariableScopeFlagValue,
@@ -36,17 +36,17 @@ import {
   promptVariableValueAsync,
   promptVariableVisibilityAsync,
 } from '../../utils/prompts';
-import { formatVariableName, isEnvironment } from '../../utils/variableUtils';
+import { formatVariableName } from '../../utils/variableUtils';
 
 interface RawUpdateFlags {
   name?: string;
   value?: string;
   scope: EASEnvironmentVariableScopeFlagValue;
-  environment?: EnvironmentVariableEnvironment[];
+  environment?: string[];
   visibility?: 'plaintext' | 'sensitive' | 'secret';
   type?: 'string' | 'file';
   'variable-name'?: string;
-  'variable-environment'?: EnvironmentVariableEnvironment;
+  'variable-environment'?: string;
   'non-interactive': boolean;
 }
 
@@ -54,11 +54,11 @@ interface UpdateFlags {
   name?: string;
   value?: string;
   scope: EnvironmentVariableScope;
-  environment?: EnvironmentVariableEnvironment[];
+  environment?: string[];
   visibility?: 'plaintext' | 'sensitive' | 'secret';
   type?: 'string' | 'file';
   'variable-name'?: string;
-  'variable-environment'?: EnvironmentVariableEnvironment;
+  'variable-environment'?: string;
   'non-interactive': boolean;
 }
 
@@ -69,7 +69,7 @@ export default class EnvUpdate extends EasCommand {
     'variable-name': Flags.string({
       description: 'Current name of the variable',
     }),
-    'variable-environment': Flags.enum<EnvironmentVariableEnvironment>({
+    'variable-environment': Flags.string({
       ...EasEnvironmentFlagParameters,
       description: 'Current environment of the variable to update',
     }),
@@ -93,7 +93,7 @@ export default class EnvUpdate extends EasCommand {
     {
       name: 'environment',
       description:
-        "Current environment of the variable to update. One of 'production', 'preview', or 'development'.",
+        "Current environment of the variable to update. Default environments are 'production', 'preview', and 'development'.",
       required: false,
     },
   ];
@@ -180,15 +180,19 @@ export default class EnvUpdate extends EasCommand {
       visibility: newVisibility,
       type: newType,
       fileName,
-    } = await this.promptForMissingFlagsAsync(selectedVariable, {
-      name,
-      value: rawValue,
-      environment: environments,
-      visibility,
-      'non-interactive': nonInteractive,
-      type,
-      scope,
-    });
+    } = await this.promptForMissingFlagsAsync(
+      selectedVariable,
+      {
+        name,
+        value: rawValue,
+        environment: environments,
+        visibility,
+        'non-interactive': nonInteractive,
+        type,
+        scope,
+      },
+      { graphqlClient, projectId }
+    );
 
     const variable = await EnvironmentVariableMutation.updateAsync(graphqlClient, {
       id: selectedVariable.id,
@@ -226,12 +230,6 @@ export default class EnvUpdate extends EasCommand {
         : EnvironmentVariableScope.Project;
 
     if (environment) {
-      environment = environment.toUpperCase();
-      if (!isEnvironment(environment)) {
-        throw new Error(
-          "Invalid environment. Use one of 'production', 'preview', or 'development'."
-        );
-      }
       return {
         ...flags,
         'variable-environment': environment,
@@ -252,7 +250,8 @@ export default class EnvUpdate extends EasCommand {
       'non-interactive': nonInteractive,
       type,
       ...rest
-    }: UpdateFlags
+    }: UpdateFlags,
+    { graphqlClient, projectId }: { graphqlClient: ExpoGraphqlClient; projectId: string }
   ): Promise<
     Omit<UpdateFlags, 'type' | 'visibility'> & {
       type?: EnvironmentSecretType;
@@ -316,7 +315,10 @@ export default class EnvUpdate extends EasCommand {
         environments = await promptVariableEnvironmentAsync({
           nonInteractive,
           multiple: true,
+          canEnterCustomEnvironment: true,
           selectedEnvironments: selectedVariable.environments ?? [],
+          graphqlClient,
+          projectId,
         });
 
         if (

packages/eas-cli/src/commands/fingerprint/compare.ts

@@ -4,7 +4,6 @@ import chalk from 'chalk';
 
 import { getExpoWebsiteBaseUrl } from '../../api';
 import { selectBranchOnAppAsync } from '../../branch/queries';
-import { EnvironmentVariableEnvironment } from '../../build/utils/environment';
 import EasCommand from '../../commandUtils/EasCommand';
 import { fetchBuildsAsync, formatBuild } from '../../commandUtils/builds';
 import { GetServerSideEnvironmentVariablesFn } from '../../commandUtils/context/ServerSideEnvironmentVariablesContextField';
@@ -97,7 +96,7 @@ export default class FingerprintCompare extends EasCommand {
     open: Flags.boolean({
       description: 'Open the fingerprint comparison in the browser',
     }),
-    environment: Flags.enum<EnvironmentVariableEnvironment>({
+    environment: Flags.string({
       ...EasEnvironmentFlagParameters,
       description:
         'If generating a fingerprint from the local directory, use the specified environment.',

packages/eas-cli/src/commands/fingerprint/generate.ts

@@ -4,7 +4,6 @@ import { Flags } from '@oclif/core';
 
 import { getExpoWebsiteBaseUrl } from '../../api';
 import { evaluateConfigWithEnvVarsAsync } from '../../build/evaluateConfigWithEnvVarsAsync';
-import { EnvironmentVariableEnvironment } from '../../build/utils/environment';
 import EasCommand from '../../commandUtils/EasCommand';
 import {
   EASEnvironmentFlag,
@@ -40,7 +39,7 @@ export default class FingerprintGenerate extends EasCommand {
       options: ['android', 'ios'],
     }),
     ...EASEnvironmentFlag,
-    environment: Flags.enum<EnvironmentVariableEnvironment>({
+    environment: Flags.string({
       ...EasEnvironmentFlagParameters,
       exclusive: ['build-profile'],
     }),

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

@@ -39,7 +39,7 @@ export default class UpdateConfigure extends EasCommand {
       vcsClient,
     } = await this.getContextAsync(UpdateConfigure, {
       nonInteractive: flags['non-interactive'],
-      withServerSideEnvironment: flags['environment'],
+      withServerSideEnvironment: flags['environment'] ?? null,
     });
 
     Log.log(

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

@@ -6,7 +6,6 @@ import nullthrows from 'nullthrows';
 
 // import { getExpoWebsiteBaseUrl } from '../../api';
 import { ensureBranchExistsAsync } from '../../branch/queries';
-import { EnvironmentVariableEnvironment } from '../../build/utils/environment';
 import { ensureRepoIsCleanAsync } from '../../build/utils/repository';
 import { getUpdateGroupUrl } from '../../build/utils/url';
 import EasCommand from '../../commandUtils/EasCommand';
@@ -79,7 +78,7 @@ type RawUpdateFlags = {
   'rollout-percentage'?: number;
   'non-interactive': boolean;
   json: boolean;
-  environment: EnvironmentVariableEnvironment | null;
+  environment?: string;
 };
 
 type UpdateFlags = {
@@ -96,7 +95,7 @@ type UpdateFlags = {
   rolloutPercentage?: number;
   json: boolean;
   nonInteractive: boolean;
-  environment: EnvironmentVariableEnvironment | null;
+  environment?: string;
 };
 
 export default class UpdatePublish extends EasCommand {
@@ -193,7 +192,7 @@ export default class UpdatePublish extends EasCommand {
       getServerSideEnvironmentVariablesAsync,
     } = await this.getContextAsync(UpdatePublish, {
       nonInteractive,
-      withServerSideEnvironment: environment,
+      withServerSideEnvironment: environment ?? null,
     });
 
     if (jsonFlag) {

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

@@ -1,28 +1,31 @@
+import { Flags } from '@oclif/core';
 import chalk from 'chalk';
 import fs from 'fs/promises';
 import fsExtra from 'fs-extra';
 import path from 'path';
-import prompts from 'prompts';
 
 import EasCommand from '../../commandUtils/EasCommand';
-import { EASNonInteractiveFlag } from '../../commandUtils/flags';
+import {
+  runBuildConfigureIfNeededAsync,
+  runUpdateConfigureIfNeededAsync,
+} from '../../commandUtils/workflow/buildProfileUtils';
+import {
+  WorkflowStarter,
+  WorkflowStarterName,
+  customizeTemplateIfNeededAsync,
+  howToRunWorkflow,
+  workflowStarters,
+} from '../../commandUtils/workflow/creation';
+import {
+  logWorkflowValidationErrors,
+  validateWorkflowFileAsync,
+  workflowContentsFromParsedYaml,
+} from '../../commandUtils/workflow/validation';
 import Log from '../../log';
+import { promptAsync } from '../../prompts';
+import formatFields from '../../utils/formatFields';
 import { WorkflowFile } from '../../utils/workflowFile';
 
-const DEFAULT_WORKFLOW_NAME = 'workflow.yml';
-const HELLO_WORLD_TEMPLATE = `name: Hello World
-
-on:
-  push:
-    branches: ['*']
-
-jobs:
-  hello_world:
-    steps:
-      - uses: eas/checkout
-      - run: echo "Hello, World"
-`;
-
 export class WorkflowCreate extends EasCommand {
   static override description = 'create a new workflow configuration YAML file';
 
@@ -35,11 +38,16 @@ export class WorkflowCreate extends EasCommand {
   ];
 
   static override flags = {
-    ...EASNonInteractiveFlag,
+    'skip-validation': Flags.boolean({
+      description: 'If set, the workflow file will not be validated before being created',
+      default: false,
+    }),
   };
 
   static override contextDefinition = {
+    ...this.ContextOptions.DynamicProjectConfig,
     ...this.ContextOptions.ProjectDir,
+    ...this.ContextOptions.LoggedIn,
   };
 
   async runAsync(): Promise<void> {
@@ -48,74 +56,175 @@ export class WorkflowCreate extends EasCommand {
       flags,
     } = await this.parse(WorkflowCreate);
 
-    const { projectDir } = await this.getContextAsync(WorkflowCreate, {
-      nonInteractive: flags['non-interactive'],
-    });
+    try {
+      const {
+        getDynamicPrivateProjectConfigAsync,
+        loggedIn: { graphqlClient },
+        projectDir,
+      } = await this.getContextAsync(WorkflowCreate, {
+        nonInteractive: false,
+        withServerSideEnvironment: null,
+      });
 
-    let fileName = argFileName;
+      const { exp: originalExpoConfig, projectId } = await getDynamicPrivateProjectConfigAsync();
+      let expoConfig = originalExpoConfig;
 
-    if (!fileName) {
-      const response = await prompts({
+      let workflowStarter;
+      while (!workflowStarter) {
+        workflowStarter = await chooseTemplateAsync();
+        switch (workflowStarter.name) {
+          case WorkflowStarterName.BUILD:
+          case WorkflowStarterName.DEPLOY:
+          case WorkflowStarterName.UPDATE: {
+            const shouldProceed = await runBuildConfigureIfNeededAsync({
+              projectDir,
+              expoConfig,
+            });
+            if (!shouldProceed) {
+              workflowStarter = undefined;
+              continue;
+            }
+            break;
+          }
+          default:
+            break;
+        }
+        switch (workflowStarter.name) {
+          case WorkflowStarterName.DEPLOY:
+          case WorkflowStarterName.UPDATE: {
+            const shouldProceed = await runUpdateConfigureIfNeededAsync({
+              projectDir,
+              expoConfig,
+            });
+            if (!shouldProceed) {
+              workflowStarter = undefined;
+              continue;
+            }
+            // Need to refetch the Expo config because it may have changed
+            expoConfig = (await getDynamicPrivateProjectConfigAsync()).exp;
+            break;
+          }
+          default:
+            break;
+        }
+      }
+
+      const { fileName, filePath } = await chooseFileNameAsync(
+        argFileName,
+        projectDir,
+        workflowStarter
+      );
+
+      // Customize the template if needed
+      workflowStarter = await customizeTemplateIfNeededAsync(
+        workflowStarter,
+        projectDir,
+        expoConfig
+      );
+
+      Log.debug(`Creating workflow file ${fileName} from template ${workflowStarter.name}`);
+      const yamlString = [
+        workflowStarter.header,
+        workflowContentsFromParsedYaml(workflowStarter.template),
+      ].join('\n');
+
+      if (!flags['skip-validation']) {
+        await validateWorkflowFileAsync(
+          { yamlConfig: yamlString, filePath: fileName },
+          projectDir,
+          graphqlClient,
+          projectId
+        );
+      }
+      await ensureWorkflowsDirectoryExistsAsync({ projectDir });
+      filePath && (await fs.writeFile(filePath, yamlString));
+      Log.withTick(`Created ${chalk.bold(filePath)}`);
+      Log.addNewLineIfNone();
+      Log.log(howToRunWorkflow(fileName, workflowStarter));
+
+      // Next steps
+      if (workflowStarter.nextSteps && workflowStarter.nextSteps.length > 0) {
+        Log.addNewLineIfNone();
+        Log.log('Next steps:');
+        Log.addNewLineIfNone();
+        Log.log(
+          formatFields(
+            workflowStarter.nextSteps.map((step: string, index: number) => ({
+              label: `${index + 1}.`,
+              value: step,
+            }))
+          )
+        );
+      }
+    } catch (error) {
+      logWorkflowValidationErrors(error);
+      Log.error('Failed to create workflow file.');
+    }
+  }
+}
+
+async function ensureWorkflowsDirectoryExistsAsync({
+  projectDir,
+}: {
+  projectDir: string;
+}): Promise<void> {
+  try {
+    await fs.access(path.join(projectDir, '.eas', 'workflows'));
+  } catch {
+    await fs.mkdir(path.join(projectDir, '.eas', 'workflows'), { recursive: true });
+    Log.withTick(`Created directory ${chalk.bold(path.join(projectDir, '.eas', 'workflows'))}`);
+  }
+}
+
+async function chooseTemplateAsync(): Promise<WorkflowStarter> {
+  const workflowStarter = (
+    await promptAsync({
+      type: 'select',
+      name: 'starter',
+      message: 'Select a workflow template:',
+      choices: workflowStarters.map(starter => ({
+        title: starter.displayName,
+        value: starter,
+      })),
+    })
+  ).starter;
+  return workflowStarter;
+}
+
+async function chooseFileNameAsync(
+  initialValue: string | undefined,
+  projectDir: string,
+  workflowStarter: WorkflowStarter
+): Promise<{ fileName: string; filePath: string }> {
+  let fileName = initialValue;
+  let filePath = '';
+  while ((fileName?.length ?? 0) === 0) {
+    fileName = (
+      await promptAsync({
         type: 'text',
         name: 'fileName',
         message: 'What would you like to name your workflow file?',
-        initial: DEFAULT_WORKFLOW_NAME,
-        validate: value => {
-          try {
-            WorkflowFile.validateYamlExtension(value);
-            return true;
-          } catch (error) {
-            return error instanceof Error ? error.message : 'Invalid file name';
-          }
-        },
-      });
-
-      if (!response.fileName) {
-        Log.warn('Workflow creation cancelled.');
-        process.exit(0);
-      }
-
-      fileName = response.fileName;
+        initial: workflowStarter.defaultFileName,
+      })
+    ).fileName;
+    if (!fileName) {
+      fileName = undefined;
+      continue;
     }
-
     try {
-      await this.ensureWorkflowsDirectoryExistsAsync({ projectDir });
-      await this.createWorkflowFileAsync({ fileName, projectDir });
+      WorkflowFile.validateYamlExtension(fileName);
     } catch (error) {
-      Log.error('Failed to create workflow file.');
-      throw error;
+      Log.error(error instanceof Error ? error.message : 'Invalid YAML file name extension');
+      fileName = undefined;
+      continue;
     }
-  }
-
-  private async ensureWorkflowsDirectoryExistsAsync({
-    projectDir,
-  }: {
-    projectDir: string;
-  }): Promise<void> {
-    try {
-      await fs.access(path.join(projectDir, '.eas', 'workflows'));
-    } catch {
-      await fs.mkdir(path.join(projectDir, '.eas', 'workflows'), { recursive: true });
-      Log.withTick(`Created directory ${chalk.bold(path.join(projectDir, '.eas', 'workflows'))}`);
-    }
-  }
-
-  private async createWorkflowFileAsync({
-    fileName,
-    projectDir,
-  }: {
-    fileName: string;
-    projectDir: string;
-  }): Promise<void> {
-    WorkflowFile.validateYamlExtension(fileName);
-
-    const filePath = path.join(projectDir, '.eas', 'workflows', fileName);
-
+    filePath = path.join(projectDir, '.eas', 'workflows', fileName);
     if (await fsExtra.pathExists(filePath)) {
-      throw new Error(`Workflow file already exists: ${filePath}`);
+      Log.error(`Workflow file already exists: ${filePath}`);
+      Log.error('Please choose a different file name.');
+      Log.newLine();
+      fileName = undefined;
     }
-
-    await fs.writeFile(filePath, HELLO_WORLD_TEMPLATE);
-    Log.withTick(`Created ${chalk.bold(filePath)}`);
   }
+  return { fileName: fileName ?? '', filePath };
 }

packages/eas-cli/src/commands/workflow/run.ts

@@ -40,6 +40,7 @@
  * ```
  */
 
+import spawnAsync from '@expo/spawn-async';
 import { Flags } from '@oclif/core';
 import { CombinedError } from '@urql/core';
 import chalk from 'chalk';
@@ -55,6 +56,7 @@ import { ExpoGraphqlClient } from '../../commandUtils/context/contextUtils/creat
 import { EASNonInteractiveFlag, EasJsonOnlyFlag } from '../../commandUtils/flags';
 import {
   WorkflowProjectSourceType,
+  WorkflowRevision,
   WorkflowRunByIdQuery,
   WorkflowRunStatus,
 } from '../../graphql/generated';
@@ -78,7 +80,8 @@ const EXIT_CODES = {
 };
 
 export default class WorkflowRun extends EasCommand {
-  static override description = 'run an EAS workflow';
+  static override description =
+    'run an EAS workflow. The entire local project directory will be packaged and uploaded to EAS servers for the workflow run, unless the --ref flag is used.';
 
   static override args = [{ name: 'file', description: 'Path to the workflow file to run' }];
 
@@ -98,6 +101,11 @@ export default class WorkflowRun extends EasCommand {
         'Add a parameter in key=value format. Use multiple instances of this flag to set multiple inputs.',
       summary: 'Set workflow inputs',
     }),
+    ref: Flags.string({
+      description:
+        "The git reference must exist in the project's git repository, and the workflow file must exist at that reference. When this flag is used, the local project is not uploaded; instead, the workflow is run from the exact state of the project at the chosen reference.",
+      summary: 'Git reference to run the workflow on',
+    }),
     ...EasJsonOnlyFlag,
   };
 
@@ -125,26 +133,70 @@ export default class WorkflowRun extends EasCommand {
       withServerSideEnvironment: null,
     });
 
-    let yamlConfig: string;
-    try {
-      const workflowFileContents = await WorkflowFile.readWorkflowFileContentsAsync({
-        projectDir,
-        filePath: args.file,
-      });
-      Log.log(`Using workflow file from ${workflowFileContents.filePath}`);
-      yamlConfig = workflowFileContents.yamlConfig;
-    } catch (err) {
-      Log.error('Failed to read workflow file.');
-
-      throw err;
-    }
-
     const {
       projectId,
       exp: { slug: projectName },
     } = await getDynamicPrivateProjectConfigAsync();
     const account = await getOwnerAccountForProjectIdAsync(graphqlClient, projectId);
 
+    let yamlConfig: string;
+    let workflowRunId: string;
+    let workflowRevisionId: string | undefined;
+    let gitRef: string | undefined;
+
+    if (flags.ref) {
+      // Run from git ref
+      const fileName = path.basename(args.file);
+      // Find the real commit, make sure the ref is valid
+      gitRef = (
+        await spawnAsync('git', ['rev-parse', flags.ref], {
+          cwd: projectDir,
+        })
+      ).output[0].trim();
+      if (!gitRef) {
+        throw new Error('Failed to resolve git reference');
+      }
+      Log.log(`Using workflow file ${fileName} at ${gitRef}`);
+      let revisionResult: WorkflowRevision | undefined;
+      try {
+        revisionResult = await WorkflowRevisionMutation.getOrCreateWorkflowRevisionFromGitRefAsync(
+          graphqlClient,
+          {
+            appId: projectId,
+            fileName,
+            gitRef,
+          }
+        );
+      } catch (err) {
+        throw new Error(
+          `Failed to find or create workflow revision for ${fileName} at ${flags.ref}: ${err}`
+        );
+      }
+      Log.debug(`Workflow revision: ${JSON.stringify(revisionResult, null, 2)}`);
+      if (!revisionResult) {
+        throw new Error(
+          `Failed to find or create workflow revision for ${fileName} at ${flags.ref}`
+        );
+      }
+      yamlConfig = revisionResult.yamlConfig;
+      workflowRevisionId = revisionResult.id;
+    } else {
+      // Run from local file
+      try {
+        const workflowFileContents = await WorkflowFile.readWorkflowFileContentsAsync({
+          projectDir,
+          filePath: args.file,
+        });
+        Log.log(`Using workflow file from ${workflowFileContents.filePath}`);
+        yamlConfig = workflowFileContents.yamlConfig;
+      } catch (err) {
+        Log.error('Failed to read workflow file.');
+
+        throw err;
+      }
+    }
+
+    // Validate workflow YAML
     try {
       await WorkflowRevisionMutation.validateWorkflowYamlConfigAsync(graphqlClient, {
         appId: projectId,
@@ -206,81 +258,95 @@ export default class WorkflowRun extends EasCommand {
       path.relative(await vcsClient.getRootPathAsync(), projectDir) || '.'
     );
 
-    try {
-      ({ projectArchiveBucketKey } = await uploadAccountScopedProjectSourceAsync({
-        graphqlClient,
-        vcsClient,
-        accountId: account.id,
-      }));
-
-      if (await fileExistsAsync(easJsonPath)) {
-        ({ fileBucketKey: easJsonBucketKey } = await uploadAccountScopedFileAsync({
-          graphqlClient,
-          accountId: account.id,
-          filePath: easJsonPath,
-          maxSizeBytes: 1024 * 1024,
-        }));
-      } else {
-        Log.warn(
-          `⚠ No ${chalk.bold('eas.json')} found in the project directory. Running ${chalk.bold(
-            'type: build'
-          )} jobs will not work. Run ${chalk.bold(
-            'eas build:configure'
-          )} to configure your project for builds.`
-        );
-      }
-
-      if (await fileExistsAsync(packageJsonPath)) {
-        ({ fileBucketKey: packageJsonBucketKey } = await uploadAccountScopedFileAsync({
-          graphqlClient,
-          accountId: account.id,
-          filePath: packageJsonPath,
-          maxSizeBytes: 1024 * 1024,
-        }));
-      } else {
-        Log.warn(
-          `⚠ No ${chalk.bold(
-            'package.json'
-          )} found in the project directory. It is used to automatically infer best job configuration for your project. You may want to define ${chalk.bold(
-            'image'
-          )} property in your workflow to specify the image to use.`
-        );
-      }
-    } catch (err) {
-      Log.error('Failed to upload project sources.');
-
-      throw err;
-    }
-
-    let workflowRunId: string;
-
-    try {
-      ({ id: workflowRunId } = await WorkflowRunMutation.createWorkflowRunAsync(graphqlClient, {
-        appId: projectId,
-        workflowRevisionInput: {
-          fileName: path.basename(args.file),
-          yamlConfig,
-        },
-        workflowRunInput: {
+    if (gitRef) {
+      // Run from git ref
+      let runResult: { id: string };
+      try {
+        runResult = await WorkflowRunMutation.createWorkflowRunFromGitRefAsync(graphqlClient, {
+          workflowRevisionId: workflowRevisionId ?? '',
+          gitRef,
           inputs,
-          projectSource: {
-            type: WorkflowProjectSourceType.Gcs,
-            projectArchiveBucketKey,
-            easJsonBucketKey,
-            packageJsonBucketKey,
-            projectRootDirectory,
+        });
+      } catch (err) {
+        throw new Error(`Failed to create workflow run: ${err}`);
+      }
+      workflowRunId = runResult.id;
+    } else {
+      // Run from local file
+      try {
+        ({ projectArchiveBucketKey } = await uploadAccountScopedProjectSourceAsync({
+          graphqlClient,
+          vcsClient,
+          accountId: account.id,
+        }));
+
+        if (await fileExistsAsync(easJsonPath)) {
+          ({ fileBucketKey: easJsonBucketKey } = await uploadAccountScopedFileAsync({
+            graphqlClient,
+            accountId: account.id,
+            filePath: easJsonPath,
+            maxSizeBytes: 1024 * 1024,
+          }));
+        } else {
+          Log.warn(
+            `⚠ No ${chalk.bold('eas.json')} found in the project directory. Running ${chalk.bold(
+              'type: build'
+            )} jobs will not work. Run ${chalk.bold(
+              'eas build:configure'
+            )} to configure your project for builds.`
+          );
+        }
+
+        if (await fileExistsAsync(packageJsonPath)) {
+          ({ fileBucketKey: packageJsonBucketKey } = await uploadAccountScopedFileAsync({
+            graphqlClient,
+            accountId: account.id,
+            filePath: packageJsonPath,
+            maxSizeBytes: 1024 * 1024,
+          }));
+        } else {
+          Log.warn(
+            `⚠ No ${chalk.bold(
+              'package.json'
+            )} found in the project directory. It is used to automatically infer best job configuration for your project. You may want to define ${chalk.bold(
+              'image'
+            )} property in your workflow to specify the image to use.`
+          );
+        }
+      } catch (err) {
+        Log.error('Failed to upload project sources.');
+
+        throw err;
+      }
+
+      try {
+        ({ id: workflowRunId } = await WorkflowRunMutation.createWorkflowRunAsync(graphqlClient, {
+          appId: projectId,
+          workflowRevisionInput: {
+            fileName: path.basename(args.file),
+            yamlConfig,
           },
-        },
-      }));
+          workflowRunInput: {
+            inputs,
+            projectSource: {
+              type: WorkflowProjectSourceType.Gcs,
+              projectArchiveBucketKey,
+              easJsonBucketKey,
+              packageJsonBucketKey,
+              projectRootDirectory,
+            },
+          },
+        }));
+      } catch (err) {
+        Log.error('Failed to start the workflow with the API.');
 
-      Log.newLine();
-      Log.log(`See logs: ${link(getWorkflowRunUrl(account.name, projectName, workflowRunId))}`);
-    } catch (err) {
-      Log.error('Failed to start the workflow with the API.');
-
-      throw err;
+        throw err;
+      }
     }
 
+    Log.newLine();
+    Log.log(`See logs: ${link(getWorkflowRunUrl(account.name, projectName, workflowRunId))}`);
+
     if (!flags.wait) {
       if (flags.json) {
         printJsonOnlyOutput({

packages/eas-cli/src/graphql/generated.ts

@@ -124,6 +124,7 @@ export type Account = {
   displayName?: Maybe<Scalars['String']['output']>;
   /** Environment secrets for an account */
   environmentSecrets: Array<EnvironmentSecret>;
+  environmentVariableEnvironments: Array<Scalars['EnvironmentVariableEnvironment']['output']>;
   /** Environment variables for an account */
   environmentVariables: Array<EnvironmentVariable>;
   /** Environment variables for an account with decrypted secret values */
@@ -1285,6 +1286,7 @@ export type App = Project & {
   devDomainName?: Maybe<AppDevDomainName>;
   /** Environment secrets for an app */
   environmentSecrets: Array<EnvironmentSecret>;
+  environmentVariableEnvironments: Array<Scalars['EnvironmentVariableEnvironment']['output']>;
   /** Environment variables for an app */
   environmentVariables: Array<EnvironmentVariable>;
   /** Environment variables for an app with decrypted secret values */
@@ -9859,6 +9861,15 @@ export type DeleteWebhookMutationVariables = Exact<{
 
 export type DeleteWebhookMutation = { __typename?: 'RootMutation', webhook: { __typename?: 'WebhookMutation', deleteWebhook: { __typename?: 'DeleteWebhookResult', id: string } } };
 
+export type GetOrCreateWorkflowRevisionFromGitRefMutationVariables = Exact<{
+  appId: Scalars['ID']['input'];
+  fileName: Scalars['String']['input'];
+  gitRef: Scalars['String']['input'];
+}>;
+
+
+export type GetOrCreateWorkflowRevisionFromGitRefMutation = { __typename?: 'RootMutation', workflowRevision: { __typename?: 'WorkflowRevisionMutation', getOrCreateWorkflowRevisionFromGitRef: { __typename?: 'WorkflowRevision', id: string, yamlConfig: string, blobSha: string, commitSha?: string | null, createdAt: any, workflow: { __typename?: 'Workflow', id: string } } } };
+
 export type ValidateWorkflowYamlConfigMutationVariables = Exact<{
   appId: Scalars['ID']['input'];
   yamlConfig: Scalars['String']['input'];
@@ -9876,6 +9887,15 @@ export type CreateWorkflowRunMutationVariables = Exact<{
 
 export type CreateWorkflowRunMutation = { __typename?: 'RootMutation', workflowRun: { __typename?: 'WorkflowRunMutation', createWorkflowRun: { __typename?: 'WorkflowRun', id: string } } };
 
+export type CreateWorkflowRunFromGitRefMutationVariables = Exact<{
+  workflowRevisionId: Scalars['ID']['input'];
+  gitRef: Scalars['String']['input'];
+  inputs?: InputMaybe<Scalars['JSONObject']['input']>;
+}>;
+
+
+export type CreateWorkflowRunFromGitRefMutation = { __typename?: 'RootMutation', workflowRun: { __typename?: 'WorkflowRunMutation', createWorkflowRunFromGitRef: { __typename?: 'WorkflowRun', id: string } } };
+
 export type CancelWorkflowRunMutationVariables = Exact<{
   workflowRunId: Scalars['ID']['input'];
 }>;
@@ -9902,7 +9922,7 @@ export type AppByIdWorkflowsQueryVariables = Exact<{
 }>;
 
 
-export type AppByIdWorkflowsQuery = { __typename?: 'RootQuery', app: { __typename?: 'AppQuery', byId: { __typename?: 'App', id: string, workflows: Array<{ __typename?: 'Workflow', id: string, name?: string | null, fileName: string, createdAt: any, updatedAt: any }> } } };
+export type AppByIdWorkflowsQuery = { __typename?: 'RootQuery', app: { __typename?: 'AppQuery', byId: { __typename?: 'App', id: string, workflows: Array<{ __typename?: 'Workflow', id: string, name?: string | null, fileName: string, createdAt: any, updatedAt: any, revisionsPaginated: { __typename?: 'WorkflowRevisionsConnection', edges: Array<{ __typename?: 'WorkflowRevisionEdge', node: { __typename?: 'WorkflowRevision', id: string, blobSha: string, commitSha?: string | null, createdAt: any, yamlConfig: string } }> } }> } } };
 
 export type AppByIdWorkflowRunsFilteredByStatusQueryVariables = Exact<{
   appId: Scalars['String']['input'];
@@ -10059,6 +10079,13 @@ export type EnvironmentSecretsByAppIdQueryVariables = Exact<{
 
 export type EnvironmentSecretsByAppIdQuery = { __typename?: 'RootQuery', app: { __typename?: 'AppQuery', byId: { __typename?: 'App', id: string, ownerAccount: { __typename?: 'Account', id: string, environmentSecrets: Array<{ __typename?: 'EnvironmentSecret', id: string, name: string, type: EnvironmentSecretType, createdAt: any }> }, environmentSecrets: Array<{ __typename?: 'EnvironmentSecret', id: string, name: string, type: EnvironmentSecretType, createdAt: any }> } } };
 
+export type AppEnvironmentVariableEnvironmentsQueryVariables = Exact<{
+  appId: Scalars['String']['input'];
+}>;
+
+
+export type AppEnvironmentVariableEnvironmentsQuery = { __typename?: 'RootQuery', app: { __typename?: 'AppQuery', byId: { __typename?: 'App', id: string, environmentVariableEnvironments: Array<any> } } };
+
 export type EnvironmentVariablesIncludingSensitiveByAppIdQueryVariables = Exact<{
   appId: Scalars['String']['input'];
   filterNames?: InputMaybe<Array<Scalars['String']['input']> | Scalars['String']['input']>;
@@ -10292,7 +10319,7 @@ export type UpdateChannelBasicInfoFragment = { __typename?: 'UpdateChannel', id:
 
 export type WebhookFragment = { __typename?: 'Webhook', id: string, event: WebhookType, url: string, createdAt: any, updatedAt: any };
 
-export type WorkflowFragment = { __typename?: 'Workflow', id: string, name?: string | null, fileName: string, createdAt: any, updatedAt: any };
+export type WorkflowFragment = { __typename?: 'Workflow', id: string, name?: string | null, fileName: string, createdAt: any, updatedAt: any, revisionsPaginated: { __typename?: 'WorkflowRevisionsConnection', edges: Array<{ __typename?: 'WorkflowRevisionEdge', node: { __typename?: 'WorkflowRevision', id: string, blobSha: string, commitSha?: string | null, createdAt: any, yamlConfig: string } }> } };
 
 export type WorkflowJobFragment = { __typename?: 'WorkflowJob', id: string, key: string, name: string, status: WorkflowJobStatus, type: WorkflowJobType, outputs: any, createdAt: any, updatedAt: any, workflowRun: { __typename?: 'WorkflowRun', id: string }, turtleJobRun?: { __typename?: 'JobRun', id: string, logFileUrls: Array<string>, artifacts: Array<{ __typename?: 'WorkflowArtifact', id: string, name: string, contentType?: string | null, fileSizeBytes?: number | null, filename: string, downloadUrl?: string | null }>, errors: Array<{ __typename?: 'JobRunError', errorCode: string, message: string }> } | null, turtleBuild?: { __typename?: 'Build', id: string, status: BuildStatus, platform: AppPlatform, channel?: string | null, distribution?: DistributionType | null, iosEnterpriseProvisioning?: BuildIosEnterpriseProvisioning | null, buildProfile?: string | null, sdkVersion?: string | null, appVersion?: string | null, appBuildVersion?: string | null, runtimeVersion?: string | null, gitCommitHash?: string | null, gitCommitMessage?: string | null, initialQueuePosition?: number | null, queuePosition?: number | null, estimatedWaitTimeLeftSeconds?: number | null, priority: BuildPriority, createdAt: any, updatedAt: any, message?: string | null, completedAt?: any | null, expirationDate?: any | null, isForIosSimulator: boolean, error?: { __typename?: 'BuildError', errorCode: string, message: string, docsUrl?: string | null } | null, artifacts?: { __typename?: 'BuildArtifacts', buildUrl?: string | null, xcodeBuildLogsUrl?: string | null, applicationArchiveUrl?: string | null, buildArtifactsUrl?: string | null } | null, fingerprint?: { __typename?: 'Fingerprint', id: string, hash: string } | null, initiatingActor?: { __typename: 'Robot', id: string, displayName: string } | { __typename: 'SSOUser', id: string, displayName: string } | { __typename: 'User', id: string, displayName: string } | null, project: { __typename: 'App', id: string, name: string, slug: string, ownerAccount: { __typename?: 'Account', id: string, name: string } } | { __typename: 'Snack', id: string, name: string, slug: string }, metrics?: { __typename?: 'BuildMetrics', buildWaitTime?: number | null, buildQueueTime?: number | null, buildDuration?: number | null } | null } | null, errors: Array<{ __typename?: 'WorkflowJobError', title: string, message: string }> };
 

packages/eas-cli/src/graphql/mutations/WorkflowRevisionMutation.ts

@@ -4,8 +4,11 @@ import { z } from 'zod';
 import { ExpoGraphqlClient } from '../../commandUtils/context/contextUtils/createGraphqlClient';
 import { withErrorHandlingAsync } from '../client';
 import {
+  GetOrCreateWorkflowRevisionFromGitRefMutation,
+  GetOrCreateWorkflowRevisionFromGitRefMutationVariables,
   ValidateWorkflowYamlConfigMutation,
   ValidateWorkflowYamlConfigMutationVariables,
+  WorkflowRevision,
 } from '../generated';
 
 export namespace WorkflowRevisionMutation {
@@ -17,6 +20,61 @@ export namespace WorkflowRevisionMutation {
     }),
   });
 
+  export async function getOrCreateWorkflowRevisionFromGitRefAsync(
+    graphqlClient: ExpoGraphqlClient,
+    {
+      appId,
+      fileName,
+      gitRef,
+    }: {
+      appId: string;
+      fileName: string;
+      gitRef: string;
+    }
+  ): Promise<WorkflowRevision | undefined> {
+    const data = await withErrorHandlingAsync(
+      graphqlClient
+        .mutation<
+          GetOrCreateWorkflowRevisionFromGitRefMutation,
+          GetOrCreateWorkflowRevisionFromGitRefMutationVariables
+        >(
+          gql`
+            mutation GetOrCreateWorkflowRevisionFromGitRef(
+              $appId: ID!
+              $fileName: String!
+              $gitRef: String!
+            ) {
+              workflowRevision {
+                getOrCreateWorkflowRevisionFromGitRef(
+                  appId: $appId
+                  fileName: $fileName
+                  gitRef: $gitRef
+                ) {
+                  id
+                  yamlConfig
+                  blobSha
+                  commitSha
+                  createdAt
+                  workflow {
+                    id
+                  }
+                }
+              }
+            }
+          `,
+          {
+            appId,
+            fileName,
+            gitRef,
+          }
+        )
+        .toPromise()
+    );
+    return (
+      (data.workflowRevision?.getOrCreateWorkflowRevisionFromGitRef as WorkflowRevision) ??
+      undefined
+    );
+  }
   export async function validateWorkflowYamlConfigAsync(
     graphqlClient: ExpoGraphqlClient,
     {

packages/eas-cli/src/graphql/mutations/WorkflowRunMutation.ts

@@ -5,6 +5,8 @@ import { withErrorHandlingAsync } from '../client';
 import {
   CancelWorkflowRunMutation,
   CancelWorkflowRunMutationVariables,
+  CreateWorkflowRunFromGitRefMutation,
+  CreateWorkflowRunFromGitRefMutationVariables,
   CreateWorkflowRunMutation,
   CreateWorkflowRunMutationVariables,
   WorkflowRevisionInput,
@@ -54,6 +56,53 @@ export namespace WorkflowRunMutation {
     );
     return { id: data.workflowRun.createWorkflowRun.id };
   }
+
+  export async function createWorkflowRunFromGitRefAsync(
+    graphqlClient: ExpoGraphqlClient,
+    {
+      workflowRevisionId,
+      gitRef,
+      inputs,
+    }: {
+      workflowRevisionId: string;
+      gitRef: string;
+      inputs?: Record<string, any>;
+    }
+  ): Promise<{ id: string }> {
+    const data = await withErrorHandlingAsync(
+      graphqlClient
+        .mutation<
+          CreateWorkflowRunFromGitRefMutation,
+          CreateWorkflowRunFromGitRefMutationVariables
+        >(
+          gql`
+            mutation CreateWorkflowRunFromGitRef(
+              $workflowRevisionId: ID!
+              $gitRef: String!
+              $inputs: JSONObject
+            ) {
+              workflowRun {
+                createWorkflowRunFromGitRef(
+                  workflowRevisionId: $workflowRevisionId
+                  gitRef: $gitRef
+                  inputs: $inputs
+                ) {
+                  id
+                }
+              }
+            }
+          `,
+          {
+            workflowRevisionId,
+            gitRef,
+            inputs,
+          }
+        )
+        .toPromise()
+    );
+    return { id: data.workflowRun.createWorkflowRunFromGitRef.id };
+  }
+
   export async function cancelWorkflowRunAsync(
     graphqlClient: ExpoGraphqlClient,
     {

packages/eas-cli/src/graphql/queries/EnvironmentVariablesQuery.ts

@@ -1,7 +1,6 @@
 import { print } from 'graphql';
 import gql from 'graphql-tag';
 
-import { EnvironmentVariableEnvironment } from '../../build/utils/environment';
 import { ExpoGraphqlClient } from '../../commandUtils/context/contextUtils/createGraphqlClient';
 import { withErrorHandlingAsync } from '../client';
 import {
@@ -14,7 +13,7 @@ import { EnvironmentVariableFragmentNode } from '../types/EnvironmentVariable';
 import { EnvironmentVariableWithSecretFragmentNode } from '../types/EnvironmentVariableWithSecret';
 
 type EnvironmentVariableWithLinkedEnvironments = EnvironmentVariableFragment & {
-  linkedEnvironments?: EnvironmentVariableEnvironment[] | null;
+  linkedEnvironments?: string[] | null;
 };
 
 export type EnvironmentVariableWithFileContent = EnvironmentVariableFragment & {
@@ -22,6 +21,31 @@ export type EnvironmentVariableWithFileContent = EnvironmentVariableFragment & {
 };
 
 export const EnvironmentVariablesQuery = {
+  async environmentVariableEnvironmentsAsync(
+    graphqlClient: ExpoGraphqlClient,
+    appId: string
+  ): Promise<string[]> {
+    const data = await withErrorHandlingAsync(
+      graphqlClient
+        .query(
+          gql`
+            query AppEnvironmentVariableEnvironments($appId: String!) {
+              app {
+                byId(appId: $appId) {
+                  id
+                  environmentVariableEnvironments
+                }
+              }
+            }
+          `,
+          { appId },
+          { additionalTypenames: ['App'] }
+        )
+        .toPromise()
+    );
+
+    return data.app?.byId.environmentVariableEnvironments ?? [];
+  },
   async byAppIdWithSensitiveAsync(
     graphqlClient: ExpoGraphqlClient,
     {
@@ -31,7 +55,7 @@ export const EnvironmentVariablesQuery = {
       includeFileContent = false,
     }: {
       appId: string;
-      environment?: EnvironmentVariableEnvironment;
+      environment?: string;
       filterNames?: string[];
       includeFileContent?: boolean;
     }
@@ -80,7 +104,7 @@ export const EnvironmentVariablesQuery = {
       includeFileContent = false,
     }: {
       appId: string;
-      environment?: EnvironmentVariableEnvironment;
+      environment?: string;
       filterNames?: string[];
       includeFileContent?: boolean;
     }
@@ -128,7 +152,7 @@ export const EnvironmentVariablesQuery = {
     }: {
       appId: string;
       filterNames?: string[];
-      environment?: EnvironmentVariableEnvironment;
+      environment?: string;
       includeFileContent?: boolean;
     }
   ): Promise<(EnvironmentVariableWithFileContent & EnvironmentVariableWithLinkedEnvironments)[]> {
@@ -178,7 +202,7 @@ export const EnvironmentVariablesQuery = {
     }: {
       appId: string;
       filterNames?: string[];
-      environment?: EnvironmentVariableEnvironment;
+      environment?: string;
       includeFileContent?: boolean;
     }
   ): Promise<EnvironmentVariableWithFileContent[]> {

packages/eas-cli/src/graphql/types/Workflow.ts

@@ -7,5 +7,16 @@ export const WorkflowFragmentNode = gql`
     fileName
     createdAt
     updatedAt
+    revisionsPaginated(first: 1) {
+      edges {
+        node {
+          id
+          blobSha
+          commitSha
+          createdAt
+          yamlConfig
+        }
+      }
+    }
   }
 `;

packages/eas-cli/src/utils/prompts.ts

@@ -1,10 +1,31 @@
 import chalk from 'chalk';
 
-import { EnvironmentVariableEnvironment } from '../build/utils/environment';
+import { DefaultEnvironment } from '../build/utils/environment';
+import { ExpoGraphqlClient } from '../commandUtils/context/contextUtils/createGraphqlClient';
 import { EnvironmentSecretType, EnvironmentVariableVisibility } from '../graphql/generated';
+import { EnvironmentVariablesQuery } from '../graphql/queries/EnvironmentVariablesQuery';
 import { RequestedPlatform } from '../platform';
 import { promptAsync, selectAsync } from '../prompts';
 
+const DEFAULT_ENVIRONMENTS = Object.values(DefaultEnvironment);
+
+export async function getProjectEnvironmentVariableEnvironmentsAsync(
+  graphqlClient: ExpoGraphqlClient,
+  projectId: string
+): Promise<string[]> {
+  try {
+    const environments = await EnvironmentVariablesQuery.environmentVariableEnvironmentsAsync(
+      graphqlClient,
+      projectId
+    );
+    return environments;
+  } catch {
+    throw new Error('Failed to fetch available environments');
+  }
+}
+
+const CUSTOM_ENVIRONMENT_VALUE = '~~CUSTOM~~';
+
 export async function promptVariableTypeAsync(
   nonInteractive: boolean,
   initialType?: EnvironmentSecretType
@@ -44,6 +65,24 @@ export function parseVisibility(
   }
 }
 
+async function promptCustomEnvironmentAsync(): Promise<string> {
+  const { customEnvironment } = await promptAsync({
+    type: 'text',
+    name: 'customEnvironment',
+    message: 'Enter custom environment name:',
+    validate: (value: string) => {
+      if (!value || value.trim() === '') {
+        return 'Environment name cannot be empty';
+      }
+      if (!value.match(/^[a-zA-Z0-9_-]+$/)) {
+        return 'Environment name may only contain letters, numbers, underscores, and hyphens';
+      }
+      return true;
+    },
+  });
+  return customEnvironment;
+}
+
 export async function promptVariableVisibilityAsync(
   nonInteractive: boolean,
   selectedVisibility?: EnvironmentVariableVisibility | null
@@ -74,49 +113,93 @@ export async function promptVariableVisibilityAsync(
 
 type EnvironmentPromptArgs = {
   nonInteractive: boolean;
-  selectedEnvironments?: EnvironmentVariableEnvironment[];
-  availableEnvironments?: EnvironmentVariableEnvironment[];
+  selectedEnvironments?: string[];
+  graphqlClient?: ExpoGraphqlClient;
+  projectId?: string;
+  canEnterCustomEnvironment?: boolean;
 };
 
 export function promptVariableEnvironmentAsync(
   input: EnvironmentPromptArgs & { multiple: true }
-): Promise<EnvironmentVariableEnvironment[]>;
+): Promise<string[]>;
 export function promptVariableEnvironmentAsync(
   input: EnvironmentPromptArgs & { multiple?: false }
-): Promise<EnvironmentVariableEnvironment>;
+): Promise<string>;
 
 export async function promptVariableEnvironmentAsync({
   nonInteractive,
   selectedEnvironments,
   multiple = false,
-  availableEnvironments,
-}: EnvironmentPromptArgs & { multiple?: boolean }): Promise<
-  EnvironmentVariableEnvironment[] | EnvironmentVariableEnvironment
-> {
+  canEnterCustomEnvironment = false,
+  graphqlClient,
+  projectId,
+}: EnvironmentPromptArgs & { multiple?: boolean }): Promise<string[] | string> {
   if (nonInteractive) {
     throw new Error(
       'The `--environment` flag must be set when running in `--non-interactive` mode.'
     );
   }
-  if (!multiple) {
-    return await selectAsync(
-      'Select environment:',
-      (availableEnvironments ?? Object.values(EnvironmentVariableEnvironment)).map(environment => ({
-        title: environment.toLocaleLowerCase(),
-        value: environment,
-      }))
+
+  let allEnvironments: string[] = DEFAULT_ENVIRONMENTS;
+  if (graphqlClient && projectId) {
+    const projectEnvironments = await getProjectEnvironmentVariableEnvironmentsAsync(
+      graphqlClient,
+      projectId
     );
+    allEnvironments = [...new Set([...DEFAULT_ENVIRONMENTS, ...projectEnvironments])];
   }
+
+  if (!multiple) {
+    const choices = allEnvironments.map(environment => ({
+      title: environment,
+      value: environment,
+    }));
+
+    if (canEnterCustomEnvironment) {
+      choices.push({
+        title: 'Other (enter custom environment)',
+        value: CUSTOM_ENVIRONMENT_VALUE,
+      });
+    }
+
+    const selectedEnvironment = await selectAsync('Select environment:', choices);
+
+    if (selectedEnvironment === CUSTOM_ENVIRONMENT_VALUE) {
+      return await promptCustomEnvironmentAsync();
+    }
+
+    return selectedEnvironment;
+  }
+
+  const choices = allEnvironments.map(environment => ({
+    title: environment,
+    value: environment,
+    selected: selectedEnvironments?.includes(environment),
+  }));
+
+  if (canEnterCustomEnvironment) {
+    choices.push({
+      title: 'Other (enter custom environment)',
+      value: CUSTOM_ENVIRONMENT_VALUE,
+      selected: false,
+    });
+  }
+
   const { environments } = await promptAsync({
     message: 'Select environment:',
     name: 'environments',
     type: 'multiselect',
-    choices: Object.values(EnvironmentVariableEnvironment).map(environment => ({
-      title: environment.toLocaleLowerCase(),
-      value: environment,
-      selected: selectedEnvironments?.includes(environment),
-    })),
+    choices,
   });
+
+  if (environments?.includes(CUSTOM_ENVIRONMENT_VALUE)) {
+    const customEnvironment = await promptCustomEnvironmentAsync();
+    const filteredEnvironments = environments.filter(
+      (env: string) => env !== CUSTOM_ENVIRONMENT_VALUE
+    );
+    return [...filteredEnvironments, customEnvironment];
+  }
+
   return environments;
 }
 

packages/eas-cli/src/utils/variableUtils.ts

@@ -1,7 +1,6 @@
 import dateFormat from 'dateformat';
 
 import formatFields from './formatFields';
-import { EnvironmentVariableEnvironment } from '../build/utils/environment';
 import {
   EnvironmentSecretType,
   EnvironmentVariableFragment,
@@ -10,12 +9,6 @@ import {
 } from '../graphql/generated';
 import { EnvironmentVariableWithFileContent } from '../graphql/queries/EnvironmentVariablesQuery';
 
-export function isEnvironment(environment: string): environment is EnvironmentVariableEnvironment {
-  return Object.values(EnvironmentVariableEnvironment).includes(
-    environment as EnvironmentVariableEnvironment
-  );
-}
-
 export function formatVariableName(variable: EnvironmentVariableFragment): string {
   const name = variable.name;
   const scope = variable.scope === EnvironmentVariableScope.Project ? 'project' : 'shared';
@@ -53,8 +46,8 @@ export function formatVariableValue(variable: EnvironmentVariableWithFileContent
 }
 
 export async function performForEnvironmentsAsync(
-  environments: EnvironmentVariableEnvironment[] | null,
-  fun: (environment: EnvironmentVariableEnvironment | undefined) => Promise<any>
+  environments: string[] | null,
+  fun: (environment: string | undefined) => Promise<any>
 ): Promise<any[]> {
   const selectedEnvironments = environments ?? [undefined];
   return await Promise.all(selectedEnvironments.map(env => fun(env)));

packages/eas-cli/src/worker/assets.ts

@@ -8,10 +8,11 @@ import path from 'node:path';
 import { pipeline } from 'node:stream/promises';
 import { pack } from 'tar-stream';
 
-import { EnvironmentVariableEnvironment } from '../build/utils/environment';
 import { ExpoGraphqlClient } from '../commandUtils/context/contextUtils/createGraphqlClient';
 import { EnvironmentVariablesQuery } from '../graphql/queries/EnvironmentVariablesQuery';
 
+const EXPO_ROUTES_PATHS = new Set(['_expo/routes.json', '_expo/.routes.json', '.expo-routes.json']);
+
 /** Returns whether a file or folder is ignored */
 function isIgnoredName(name: string): boolean {
   switch (name) {
@@ -114,6 +115,8 @@ export async function collectAssetsAsync(
         throw new Error(
           `Upload of "${file.normalizedPath}" aborted: File size is greater than the upload limit (>500MB)`
         );
+      } else if (EXPO_ROUTES_PATHS.has(file.normalizedPath)) {
+        continue;
       }
       const sha512$ = computeSha512HashAsync(file.path);
       const contentType$ = determineMimeTypeAsync(file.path);
@@ -129,6 +132,31 @@ export async function collectAssetsAsync(
   return assets;
 }
 
+export interface RoutesConfigEntry {
+  headers?: Record<string, unknown>;
+  redirects?: Record<string, unknown>[];
+}
+
+export async function getRoutesConfigAsync(
+  assetPath: string | undefined
+): Promise<RoutesConfigEntry | null> {
+  if (assetPath) {
+    for (const candidatePath of EXPO_ROUTES_PATHS) {
+      const targetPath = path.resolve(assetPath, candidatePath);
+      let json: unknown;
+      try {
+        json = JSON.parse(await fs.promises.readFile(targetPath, 'utf8'));
+      } catch {
+        continue;
+      }
+      if (typeof json === 'object' && json) {
+        return json as RoutesConfigEntry;
+      }
+    }
+  }
+  return null;
+}
+
 /** Mapping of normalized file paths to a SHA512 hash */
 export type AssetMap = Record<
   string,
@@ -162,7 +190,7 @@ export interface CreateManifestResult {
 interface CreateManifestParams {
   projectId: string;
   projectDir: string;
-  environment?: EnvironmentVariableEnvironment;
+  environment?: string;
 }
 
 /** Creates a manifest configuration sent up for deployment */

packages/eas-json/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@expo/eas-json",
   "description": "A library for interacting with eas.json",
-  "version": "16.20.1",
+  "version": "16.23.0",
   "author": "Expo <[email protected]>",
   "bugs": "https://github.com/expo/eas-cli/issues",
   "dependencies": {

packages/eas-json/schema/eas.schema.json

@@ -214,7 +214,8 @@
         "environment": {
           "description": "Environment to use for the server-side defined EAS environment variables during build process and command execution. Learn more: https://docs.expo.dev/eas/environment-variables/",
           "markdownDescription": "Environment to use for the server-side defined EAS environment variables during build process and command execution. [Learn more](https://docs.expo.dev/eas/environment-variables/)",
-          "enum": ["production", "preview", "development"]
+          "examples": ["production", "preview", "development"],
+          "type": "string"
         },
         "android": {
           "$ref": "#/definitions/BuildProfileAndroid"

packages/eas-json/src/__tests__/buildProfiles-test.ts

@@ -129,6 +129,35 @@ test('valid eas.json with specified environment', async () => {
   });
 });
 
+test('supports custom environment names', async () => {
+  await fs.writeJson('/project/eas.json', {
+    build: {
+      development: {
+        environment: 'my-custom-environment',
+      },
+    },
+  });
+
+  const accessor = EasJsonAccessor.fromProjectPath('/project');
+  const iosProfile = await EasJsonUtils.getBuildProfileAsync(accessor, Platform.IOS, 'development');
+  const androidProfile = await EasJsonUtils.getBuildProfileAsync(
+    accessor,
+    Platform.ANDROID,
+    'development'
+  );
+  expect(androidProfile).toEqual({
+    credentialsSource: 'remote',
+    distribution: 'store',
+    environment: 'my-custom-environment',
+  });
+
+  expect(iosProfile).toEqual({
+    credentialsSource: 'remote',
+    distribution: 'store',
+    environment: 'my-custom-environment',
+  });
+});
+
 test('valid eas.json with specified keystoreName', async () => {
   const keystoreName = 'this-is-a-keystore-name';
   await fs.writeJson('/project/eas.json', {

packages/eas-json/src/build/schema.ts

@@ -71,7 +71,15 @@ const CommonBuildProfileSchema = Joi.object({
   // credentials
   withoutCredentials: Joi.boolean(),
 
-  environment: Joi.string().valid('preview', 'production', 'development'),
+  environment: Joi.string()
+    .min(3)
+    .max(100)
+    .pattern(/^[a-z0-9_-]+$/)
+    .messages({
+      'string.min': 'Environment name must be at least 3 characters.',
+      'string.max': 'Environment name must not be longer than 100 characters.',
+      'string.pattern.base': 'Environment name can only contain lowercase letters, numbers, dashes and underscores.',
+    }),
 });
 
 const PlatformBuildProfileSchema = CommonBuildProfileSchema.concat(

packages/eas-json/src/build/types.ts

@@ -71,7 +71,7 @@ export interface CommonBuildProfile {
   // credentials
   withoutCredentials?: boolean;
 
-  environment?: 'preview' | 'production' | 'development';
+  environment?: string;
 }
 
 interface PlatformBuildProfile extends Omit<CommonBuildProfile, 'autoIncrement'> {

yarn.lock

@@ -1549,6 +1549,16 @@
     semver "^7.6.2"
     zod "^4.1.3"
 
+"@expo/[email protected]":
+  version "1.0.237"
+  resolved "https://registry.yarnpkg.com/@expo/eas-build-job/-/eas-build-job-1.0.237.tgz#2a3230540ac85599ee51d01b62c9d7b74ccfad2a"
+  integrity sha512-bvE7/+QO6hcyeD7Jn5job4jRZJNLep7MDaOsYTZ66xRNYiqY8g2TMKTcg8oOaBvhv8i5WJMJOexNmzkxWFjUtw==
+  dependencies:
+    "@expo/logger" "1.0.221"
+    joi "^17.13.1"
+    semver "^7.6.2"
+    zod "^4.1.3"
+
 "@expo/env@^1.0.0":
   version "1.0.0"
   resolved "https://registry.yarnpkg.com/@expo/env/-/env-1.0.0.tgz#8e22894fae04ba6dc41fe0f1351a4973d410273a"