eas-cli 12.5.2 → 12.5.4

package/build/commands/env/create.js

@@ -4,6 +4,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
 const core_1 = require("@oclif/core");
 const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const fs_extra_1 = tslib_1.__importDefault(require("fs-extra"));
+const path_1 = tslib_1.__importDefault(require("path"));
 const EasCommand_1 = tslib_1.__importDefault(require("../../commandUtils/EasCommand"));
 const flags_1 = require("../../commandUtils/flags");
 const generated_1 = require("../../graphql/generated");
@@ -18,7 +20,7 @@ class EnvironmentVariableCreate extends EasCommand_1.default {
     async runAsync() {
         const { flags } = await this.parse(_a);
         const validatedFlags = this.validateFlags(flags);
-        const { name, value, scope, 'non-interactive': nonInteractive, environment: environments, visibility, link, force, } = await this.promptForMissingFlagsAsync(validatedFlags);
+        const { name, value, scope, 'non-interactive': nonInteractive, environment: environments, visibility, link, force, type, } = await this.promptForMissingFlagsAsync(validatedFlags);
         const { privateProjectConfig: { projectId }, loggedIn: { graphqlClient }, } = await this.getContextAsync(_a, {
             nonInteractive,
         });
@@ -63,13 +65,14 @@ class EnvironmentVariableCreate extends EasCommand_1.default {
                     value,
                     visibility,
                     environments,
+                    type,
                 })
                 : await EnvironmentVariableMutation_1.EnvironmentVariableMutation.createForAppAsync(graphqlClient, {
                     name,
                     value,
                     environments,
                     visibility,
-                    type: generated_1.EnvironmentSecretType.String,
+                    type: type ?? generated_1.EnvironmentSecretType.String,
                 }, projectId);
             if (!variable) {
                 throw new Error(`Could not create variable with name ${name} on project ${projectDisplayName}`);
@@ -98,13 +101,14 @@ class EnvironmentVariableCreate extends EasCommand_1.default {
                     value,
                     visibility,
                     environments,
+                    type,
                 })
                 : await EnvironmentVariableMutation_1.EnvironmentVariableMutation.createSharedVariableAsync(graphqlClient, {
                     name,
                     value,
                     visibility,
                     environments,
-                    type: generated_1.EnvironmentSecretType.String,
+                    type: type ?? generated_1.EnvironmentSecretType.String,
                 }, ownerAccount.id);
             if (!variable) {
                 throw new Error(`Could not create variable with name ${name} on account ${ownerAccount.name}`);
@@ -133,34 +137,62 @@ class EnvironmentVariableCreate extends EasCommand_1.default {
             throw new Error(`${message} Use --force to overwrite it.`);
         }
     }
-    async promptForMissingFlagsAsync({ name, value, environment, visibility = generated_1.EnvironmentVariableVisibility.Public, 'non-interactive': nonInteractive, ...rest }) {
+    async promptForMissingFlagsAsync({ name, value, environment, visibility, 'non-interactive': nonInteractive, type, ...rest }) {
         if (!name) {
             name = await (0, prompts_2.promptVariableNameAsync)(nonInteractive);
         }
+        let newType;
+        let newVisibility = visibility ? (0, prompts_2.parseVisibility)(visibility) : undefined;
+        if (type === 'file') {
+            newType = generated_1.EnvironmentSecretType.FileBase64;
+        }
+        else if (type === 'string') {
+            newType = generated_1.EnvironmentSecretType.String;
+        }
+        if (!type && !value && !nonInteractive) {
+            newType = await (0, prompts_2.promptVariableTypeAsync)(nonInteractive);
+        }
+        if (!newVisibility) {
+            newVisibility = await (0, prompts_2.promptVariableVisibilityAsync)(nonInteractive);
+        }
         if (!value) {
             value = await (0, prompts_2.promptVariableValueAsync)({
                 nonInteractive,
-                hidden: visibility !== generated_1.EnvironmentVariableVisibility.Public,
+                hidden: newVisibility !== generated_1.EnvironmentVariableVisibility.Public,
+                filePath: newType === generated_1.EnvironmentSecretType.FileBase64,
             });
         }
+        let environmentFilePath;
+        if (newType === generated_1.EnvironmentSecretType.FileBase64) {
+            environmentFilePath = path_1.default.resolve(value);
+            if (!(await fs_extra_1.default.pathExists(environmentFilePath))) {
+                throw new Error(`File "${value}" does not exist`);
+            }
+        }
+        value = environmentFilePath ? await fs_extra_1.default.readFile(environmentFilePath, 'base64') : value;
         if (!environment) {
             environment = await (0, prompts_2.promptVariableEnvironmentAsync)({ nonInteractive, multiple: true });
+            if (!environment || environment.length === 0) {
+                throw new Error('No environments selected');
+            }
         }
+        newVisibility = newVisibility ?? generated_1.EnvironmentVariableVisibility.Public;
         return {
             name,
             value,
             environment,
-            visibility,
+            visibility: newVisibility,
             link: rest.link ?? false,
             force: rest.force ?? false,
             scope: rest.scope ?? generated_1.EnvironmentVariableScope.Project,
             'non-interactive': nonInteractive,
+            type: newType,
             ...rest,
         };
     }
     validateFlags(flags) {
         if (flags.scope !== generated_1.EnvironmentVariableScope.Shared && flags.link) {
-            throw new Error(`Unexpected argument: --link can only be used when creating  shared variables`);
+            throw new Error(`Unexpected argument: --link can only be used when creating shared variables`);
         }
         if (flags.scope === generated_1.EnvironmentVariableScope.Shared &&
             flags.environment &&
@@ -188,6 +220,10 @@ EnvironmentVariableCreate.flags = {
         description: 'Overwrite existing variable',
         default: false,
     }),
+    type: core_1.Flags.enum({
+        description: 'The type of variable',
+        options: ['string', 'file'],
+    }),
     ...flags_1.EASVariableVisibilityFlag,
     ...flags_1.EASVariableScopeFlag,
     ...flags_1.EASMultiEnvironmentFlag,

package/build/commands/env/get.js

@@ -3,7 +3,6 @@ var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
 const core_1 = require("@oclif/core");
-const assert_1 = tslib_1.__importDefault(require("assert"));
 const chalk_1 = tslib_1.__importDefault(require("chalk"));
 const EasCommand_1 = tslib_1.__importDefault(require("../../commandUtils/EasCommand"));
 const flags_1 = require("../../commandUtils/flags");
@@ -22,6 +21,12 @@ class EnvironmentVariableGet extends EasCommand_1.default {
         if (!name) {
             name = await (0, prompts_1.promptVariableNameAsync)(nonInteractive);
         }
+        if (!environment) {
+            environment = await (0, prompts_1.promptVariableEnvironmentAsync)({
+                nonInteractive,
+                multiple: false,
+            });
+        }
         const variables = await getVariablesAsync(graphqlClient, scope, projectId, name, environment);
         if (variables.length === 0) {
             log_1.default.error(`Variable with name "${name}" not found`);
@@ -29,29 +34,20 @@ class EnvironmentVariableGet extends EasCommand_1.default {
         }
         let variable;
         if (variables.length > 1) {
-            if (!environment) {
-                const availableEnvironments = variables.reduce((acc, v) => [...acc, ...(v.environments ?? [])], []);
-                environment = await (0, prompts_1.promptVariableEnvironmentAsync)({
-                    nonInteractive,
-                    multiple: false,
-                    availableEnvironments,
-                });
-            }
-            (0, assert_1.default)(environment, 'Environment is required.');
             const variableInEnvironment = variables.find(v => v.environments?.includes(environment));
             if (!variableInEnvironment) {
-                throw new Error(`Variable with name "${name}" not found in environment "${environment}"`);
+                throw new Error(`Variable with name "${name}" not found in environment "${environment.toLocaleLowerCase()}"`);
             }
             variable = variableInEnvironment;
         }
         else {
             variable = variables[0];
         }
-        if (!variable.value) {
+        if (variable.visibility === generated_1.EnvironmentVariableVisibility.Secret) {
             throw new Error(`${chalk_1.default.bold(variable.name)} is a secret variable and cannot be displayed once it has been created.`);
         }
         if (format === 'short') {
-            log_1.default.log(`${chalk_1.default.bold(variable.name)}=${variable.value}`);
+            log_1.default.log(`${chalk_1.default.bold(variable.name)}=${(0, variableUtils_1.formatVariableValue)(variable)}`);
         }
         else {
             log_1.default.log((0, variableUtils_1.formatVariable)(variable));
@@ -101,6 +97,7 @@ async function getVariablesAsync(graphqlClient, scope, projectId, name, environm
             appId: projectId,
             environment,
             filterNames: [name],
+            includeFileContent: true,
         });
         return appVariables;
     }
@@ -108,6 +105,7 @@ async function getVariablesAsync(graphqlClient, scope, projectId, name, environm
         const sharedVariables = await EnvironmentVariablesQuery_1.EnvironmentVariablesQuery.sharedWithSensitiveAsync(graphqlClient, {
             appId: projectId,
             filterNames: [name],
+            includeFileContent: true,
         });
         return sharedVariables;
     }

package/build/commands/env/link.js

@@ -28,6 +28,9 @@ class EnvironmentVariableLink extends EasCommand_1.default {
         });
         let selectedVariable = variables[0];
         if (variables.length > 1) {
+            if (nonInteractive) {
+                throw new Error('Multiple variables found, run command with --variable-name and --variable-environment arguments.');
+            }
             selectedVariable = await (0, prompts_1.selectAsync)('Select shared variable', variables.map(variable => ({
                 title: (0, variableUtils_1.formatVariableName)(variable),
                 value: variable,

package/build/commands/env/list.d.ts

@@ -12,6 +12,7 @@ export default class EnvironmentValueList extends EasCommand {
         scope: import("@oclif/core/lib/interfaces").OptionFlag<EnvironmentVariableScope>;
         format: import("@oclif/core/lib/interfaces").OptionFlag<string>;
         'include-sensitive': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        'include-file-content': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
     };
     runAsync(): Promise<void>;
 }

package/build/commands/env/list.js

@@ -11,29 +11,36 @@ const EnvironmentVariablesQuery_1 = require("../../graphql/queries/EnvironmentVa
 const log_1 = tslib_1.__importDefault(require("../../log"));
 const prompts_1 = require("../../utils/prompts");
 const variableUtils_1 = require("../../utils/variableUtils");
-async function getVariablesForScopeAsync(graphqlClient, { scope, includingSensitive, environment, projectId, }) {
+async function getVariablesForScopeAsync(graphqlClient, { scope, includingSensitive, includeFileContent, environment, projectId, }) {
     if (scope === generated_1.EnvironmentVariableScope.Project) {
         if (includingSensitive) {
             return await EnvironmentVariablesQuery_1.EnvironmentVariablesQuery.byAppIdWithSensitiveAsync(graphqlClient, {
                 appId: projectId,
                 environment,
+                includeFileContent,
             });
         }
         return await EnvironmentVariablesQuery_1.EnvironmentVariablesQuery.byAppIdAsync(graphqlClient, {
             appId: projectId,
             environment,
+            includeFileContent,
         });
     }
     return includingSensitive
         ? await EnvironmentVariablesQuery_1.EnvironmentVariablesQuery.sharedWithSensitiveAsync(graphqlClient, {
             appId: projectId,
             environment,
+            includeFileContent,
         })
-        : await EnvironmentVariablesQuery_1.EnvironmentVariablesQuery.sharedAsync(graphqlClient, { appId: projectId, environment });
+        : await EnvironmentVariablesQuery_1.EnvironmentVariablesQuery.sharedAsync(graphqlClient, {
+            appId: projectId,
+            environment,
+            includeFileContent,
+        });
 }
 class EnvironmentValueList extends EasCommand_1.default {
     async runAsync() {
-        let { flags: { environment: environments, format, scope, 'include-sensitive': includeSensitive, 'non-interactive': nonInteractive, }, } = await this.parse(_a);
+        let { flags: { environment: environments, format, scope, 'include-sensitive': includeSensitive, 'include-file-content': includeFileContent, 'non-interactive': nonInteractive, }, } = await this.parse(_a);
         const { privateProjectConfig: { projectId }, loggedIn: { graphqlClient }, } = await this.getContextAsync(_a, {
             nonInteractive: true,
         });
@@ -44,18 +51,21 @@ class EnvironmentValueList extends EasCommand_1.default {
             const variables = await getVariablesForScopeAsync(graphqlClient, {
                 scope,
                 includingSensitive: includeSensitive,
+                includeFileContent,
                 environment,
                 projectId,
             });
             log_1.default.addNewLineIfNone();
             if (environment) {
-                log_1.default.log(chalk_1.default.bold(`Environment: ${environment}`));
+                log_1.default.log(chalk_1.default.bold(`Environment: ${environment.toLocaleLowerCase()}`));
+            }
+            if (variables.length === 0) {
+                log_1.default.log('No variables found for this environment.');
+                return;
             }
             if (format === 'short') {
                 for (const variable of variables) {
-                    // TODO: Add Learn more link
-                    log_1.default.log(`${chalk_1.default.bold(variable.name)}=${variable.value ??
-                        "***** (This is a secret env variable that can only be accessed on EAS builder and can't be read in any UI. Learn more.)"}`);
+                    log_1.default.log(`${chalk_1.default.bold(variable.name)}=${(0, variableUtils_1.formatVariableValue)(variable)}`);
                 }
             }
             else {
@@ -82,6 +92,10 @@ EnvironmentValueList.flags = {
         description: 'Display sensitive values in the output',
         default: false,
     }),
+    'include-file-content': core_1.Flags.boolean({
+        description: 'Display files content in the output',
+        default: false,
+    }),
     ...flags_1.EASVariableFormatFlag,
     ...flags_1.EASVariableScopeFlag,
     ...flags_1.EASMultiEnvironmentFlag,

package/build/commands/env/pull.js

@@ -33,7 +33,7 @@ class EnvironmentVariablePull extends EasCommand_1.default {
                 throw new Error(`File ${targetPath} already exists.`);
             }
         }
-        const filePrefix = `# Environment: ${environment}\n\n`;
+        const filePrefix = `# Environment: ${environment.toLocaleLowerCase()}\n\n`;
         const envFileContent = environmentVariables
             .map((variable) => {
             if (variable.value === null) {

package/build/commands/env/push.d.ts

@@ -9,7 +9,7 @@ export default class EnvironmentVariablePush extends EasCommand {
     };
     static flags: {
         path: import("@oclif/core/lib/interfaces").OptionFlag<string>;
-        environment: import("@oclif/core/lib/interfaces").OptionFlag<EnvironmentVariableEnvironment | undefined>;
+        environment: import("@oclif/core/lib/interfaces").OptionFlag<EnvironmentVariableEnvironment[] | undefined>;
     };
     runAsync(): Promise<void>;
     private parseEnvFileAsync;

package/build/commands/env/push.js

@@ -15,87 +15,93 @@ const prompts_1 = require("../../prompts");
 class EnvironmentVariablePush extends EasCommand_1.default {
     async runAsync() {
         const { flags } = await this.parse(_a);
-        const { environment, path: envPath } = this.validateFlags(flags);
+        const { environment: environments, path: envPath } = this.validateFlags(flags);
         const { privateProjectConfig: { projectId }, loggedIn: { graphqlClient }, } = await this.getContextAsync(_a, {
             nonInteractive: false,
         });
-        const updateVariables = await this.parseEnvFileAsync(envPath, environment);
+        const updateVariables = await this.parseEnvFileAsync(envPath, environments);
         const variableNames = Object.keys(updateVariables);
-        const existingVariables = await EnvironmentVariablesQuery_1.EnvironmentVariablesQuery.byAppIdAsync(graphqlClient, {
-            appId: projectId,
-            environment,
-            filterNames: variableNames,
-        });
-        const existingDifferentVariables = [];
-        // Remove variables that are the same as the ones in the environment
-        existingVariables.forEach(variable => {
-            const existingVariableUpdate = updateVariables[variable.name];
-            if (existingVariableUpdate && existingVariableUpdate.value !== variable.value) {
-                existingDifferentVariables.push(variable);
-            }
-            else {
-                delete updateVariables[variable.name];
-            }
-        });
-        const existingDifferentSharedVariables = existingDifferentVariables.filter(variable => variable.scope === generated_1.EnvironmentVariableScope.Shared);
-        if (existingDifferentSharedVariables.length > 0) {
-            const existingDifferentSharedVariablesNames = existingDifferentSharedVariables.map(variable => variable.name);
-            log_1.default.error('Shared variables cannot be overwritten by eas env:push command.');
-            log_1.default.error('Remove them from the env file or unlink them from the project to continue:');
-            existingDifferentSharedVariablesNames.forEach(name => {
-                log_1.default.error(`- ${name}`);
+        for (const environment of environments) {
+            const displayedEnvironment = environment.toLocaleLowerCase();
+            const existingVariables = await EnvironmentVariablesQuery_1.EnvironmentVariablesQuery.byAppIdAsync(graphqlClient, {
+                appId: projectId,
+                environment,
+                filterNames: variableNames,
             });
-            throw new Error('Shared variables cannot be overwritten by eas env:push command');
-        }
-        if (existingDifferentVariables.length > 0) {
-            log_1.default.warn('Some variables already exist in the environment.');
-            const variableNames = existingDifferentVariables.map(variable => variable.name);
-            const confirmationMessage = variableNames.length > 1
-                ? `The ${variableNames.join(', ')} environment variables already exist in ${environment} environment. Do you want to override them all?`
-                : `The ${variableNames[0]} environment variable already exists in ${environment} environment. Do you want to override it?`;
-            const confirm = await (0, prompts_1.confirmAsync)({
-                message: confirmationMessage,
+            const existingDifferentVariables = [];
+            // Remove variables that are the same as the ones in the environment
+            existingVariables.forEach(existingVariable => {
+                const existingVariableUpdate = updateVariables[existingVariable.name];
+                if (existingVariableUpdate) {
+                    const hasMoreEnvironments = existingVariableUpdate.environments.some(newEnv => !existingVariable.environments?.includes(newEnv));
+                    if (existingVariableUpdate.value !== existingVariable.value || hasMoreEnvironments) {
+                        existingDifferentVariables.push(existingVariable);
+                    }
+                    else {
+                        delete updateVariables[existingVariable.name];
+                    }
+                }
             });
-            let variablesToOverwrite = [];
-            if (!confirm && existingDifferentVariables.length === 1) {
-                throw new Error('No new variables to push.');
-            }
-            if (confirm) {
-                variablesToOverwrite = existingDifferentVariables.map(variable => variable.name);
-            }
-            else {
-                const promptResult = await (0, prompts_1.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 existingDifferentSharedVariables = existingDifferentVariables.filter(variable => variable.scope === generated_1.EnvironmentVariableScope.Shared);
+            if (existingDifferentSharedVariables.length > 0) {
+                const existingDifferentSharedVariablesNames = existingDifferentSharedVariables.map(variable => variable.name);
+                log_1.default.error('Shared variables cannot be overwritten by eas env:push command.');
+                log_1.default.error('Remove them from the env file or unlink them from the project to continue:');
+                existingDifferentSharedVariablesNames.forEach(name => {
+                    log_1.default.error(`- ${name}`);
                 });
-                variablesToOverwrite = promptResult.variablesToOverwrite;
+                throw new Error('Shared variables cannot be overwritten by eas env:push command');
             }
-            for (const existingVariable of existingVariables) {
-                const name = existingVariable.name;
-                if (variablesToOverwrite.includes(name)) {
-                    updateVariables[name]['overwrite'] = true;
+            if (existingDifferentVariables.length > 0) {
+                log_1.default.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 (0, prompts_1.confirmAsync)({
+                    message: confirmationMessage,
+                });
+                let variablesToOverwrite = [];
+                if (!confirm && existingDifferentVariables.length === 0) {
+                    throw new Error('No new variables to push.');
+                }
+                if (confirm) {
+                    variablesToOverwrite = existingDifferentVariables.map(variable => variable.name);
                 }
                 else {
-                    delete updateVariables[name];
+                    const promptResult = await (0, prompts_1.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) {
+                    const name = existingVariable.name;
+                    if (variablesToOverwrite.includes(name)) {
+                        updateVariables[name]['overwrite'] = true;
+                    }
+                    else {
+                        delete updateVariables[name];
+                    }
                 }
             }
-        }
-        // Check if any of the sensitive variables already exist in the environment. Prompt the user to overwrite them.
-        const existingSensitiveVariables = existingVariables.filter(variable => variable.value === null);
-        if (existingSensitiveVariables.length > 0) {
-            const existingSensitiveVariablesNames = existingSensitiveVariables.map(variable => `- ${variable.name}`);
-            const confirm = await (0, prompts_1.confirmAsync)({
-                message: `You are about to overwrite sensitive variables.\n${existingSensitiveVariablesNames.join('\n')}\n Do you want to continue?`,
-            });
-            if (!confirm) {
-                throw new Error('Aborting...');
+            // Check if any of the sensitive variables already exist in the environment. Prompt the user to overwrite them.
+            const existingSensitiveVariables = existingVariables.filter(variable => variable.visibility !== generated_1.EnvironmentVariableVisibility.Public);
+            if (existingSensitiveVariables.length > 0) {
+                const existingSensitiveVariablesNames = existingSensitiveVariables.map(variable => `- ${variable.name}`);
+                const confirm = await (0, prompts_1.confirmAsync)({
+                    message: `You are about to overwrite sensitive variables.\n${existingSensitiveVariablesNames.join('\n')}\n Do you want to continue?`,
+                });
+                if (!confirm) {
+                    throw new Error('Aborting...');
+                }
             }
         }
         const variablesToPush = Object.values(updateVariables);
@@ -104,9 +110,9 @@ class EnvironmentVariablePush extends EasCommand_1.default {
             return;
         }
         await EnvironmentVariableMutation_1.EnvironmentVariableMutation.createBulkEnvironmentVariablesForAppAsync(graphqlClient, variablesToPush, projectId);
-        log_1.default.log(`Uploaded env file to ${environment} environment.`);
+        log_1.default.log(`Uploaded env file to ${environments.join(', ').toLocaleLowerCase()}.`);
     }
-    async parseEnvFileAsync(envPath, environment) {
+    async parseEnvFileAsync(envPath, environments) {
         if (!(await fs_extra_1.default.exists(envPath))) {
             throw new Error(`File ${envPath} does not exist.`);
         }
@@ -116,7 +122,7 @@ class EnvironmentVariablePush extends EasCommand_1.default {
             pushInput[name] = {
                 name,
                 value,
-                environment,
+                environments,
                 visibility: name.startsWith('EXPO_SENSITIVE')
                     ? generated_1.EnvironmentVariableVisibility.Sensitive
                     : generated_1.EnvironmentVariableVisibility.Public,
@@ -125,7 +131,7 @@ class EnvironmentVariablePush extends EasCommand_1.default {
         return pushInput;
     }
     validateFlags(flags) {
-        if (!flags.environment) {
+        if (!flags.environment || flags.environment.length === 0) {
             throw new Error('Please provide an environment to push the env file to.');
         }
         return { ...flags, environment: flags.environment };
@@ -139,7 +145,7 @@ EnvironmentVariablePush.contextDefinition = {
     ..._a.ContextOptions.LoggedIn,
 };
 EnvironmentVariablePush.flags = {
-    ...flags_1.EASEnvironmentFlag,
+    ...flags_1.EASMultiEnvironmentFlag,
     path: core_1.Flags.string({
         description: 'Path to the input `.env` file',
         default: '.env.local',

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

@@ -1,5 +1,5 @@
 import EasCommand from '../../commandUtils/EasCommand';
-import { EnvironmentVariableEnvironment, EnvironmentVariableScope, EnvironmentVariableVisibility } from '../../graphql/generated';
+import { EnvironmentVariableEnvironment, EnvironmentVariableScope } from '../../graphql/generated';
 export default class EnvironmentVariableUpdate extends EasCommand {
     static description: string;
     static hidden: boolean;
@@ -7,11 +7,12 @@ export default class EnvironmentVariableUpdate extends EasCommand {
         'non-interactive': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
         environment: import("@oclif/core/lib/interfaces").OptionFlag<EnvironmentVariableEnvironment[] | undefined>;
         scope: import("@oclif/core/lib/interfaces").OptionFlag<EnvironmentVariableScope>;
-        visibility: import("@oclif/core/lib/interfaces").OptionFlag<EnvironmentVariableVisibility | undefined>;
+        visibility: import("@oclif/core/lib/interfaces").OptionFlag<"plaintext" | "encrypted" | "sensitive" | undefined>;
         'variable-name': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined>;
         'variable-environment': import("@oclif/core/lib/interfaces").OptionFlag<EnvironmentVariableEnvironment | undefined>;
         name: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined>;
         value: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined>;
+        type: import("@oclif/core/lib/interfaces").OptionFlag<"string" | "file" | undefined>;
     };
     static contextDefinition: {
         loggedIn: import("../../commandUtils/context/LoggedInContextField").default;
@@ -20,4 +21,5 @@ export default class EnvironmentVariableUpdate extends EasCommand {
     };
     runAsync(): Promise<void>;
     private validateFlags;
+    private promptForMissingFlagsAsync;
 }