eas-cli 12.5.1 → 12.5.3

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

@@ -5,13 +5,14 @@ export default class EnvironmentVariableCreate extends EasCommand {
     static hidden: boolean;
     static flags: {
         'non-interactive': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
-        environment: import("@oclif/core/lib/interfaces").OptionFlag<EnvironmentVariableEnvironment | undefined>;
+        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>;
         name: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined>;
         value: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined>;
         link: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
         force: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        type: import("@oclif/core/lib/interfaces").OptionFlag<"string" | "file" | undefined>;
     };
     static contextDefinition: {
         loggedIn: import("../../commandUtils/context/LoggedInContextField").default;
@@ -19,5 +20,7 @@ export default class EnvironmentVariableCreate extends EasCommand {
         privateProjectConfig: import("../../commandUtils/context/PrivateProjectConfigContextField").PrivateProjectConfigContextField;
     };
     runAsync(): Promise<void>;
+    private promptForOverwriteAsync;
+    private promptForMissingFlagsAsync;
     private validateFlags;
 }

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");
@@ -13,10 +15,12 @@ const log_1 = tslib_1.__importDefault(require("../../log"));
 const projectUtils_1 = require("../../project/projectUtils");
 const prompts_1 = require("../../prompts");
 const prompts_2 = require("../../utils/prompts");
+const variableUtils_1 = require("../../utils/variableUtils");
 class EnvironmentVariableCreate extends EasCommand_1.default {
     async runAsync() {
         const { flags } = await this.parse(_a);
-        let { name, value, scope, 'non-interactive': nonInteractive, environment, visibility, link, force, } = this.validateFlags(flags);
+        const validatedFlags = this.validateFlags(flags);
+        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,
         });
@@ -24,108 +28,159 @@ class EnvironmentVariableCreate extends EasCommand_1.default {
             (0, projectUtils_1.getDisplayNameForProjectIdAsync)(graphqlClient, projectId),
             (0, projectUtils_1.getOwnerAccountForProjectIdAsync)(graphqlClient, projectId),
         ]);
-        if (!name) {
-            name = await (0, prompts_2.promptVariableNameAsync)(nonInteractive);
-        }
         let overwrite = false;
-        visibility = visibility ?? generated_1.EnvironmentVariableVisibility.Public;
-        if (!value) {
-            value = await (0, prompts_2.promptVariableValueAsync)({
-                nonInteractive,
-                hidden: visibility !== generated_1.EnvironmentVariableVisibility.Public,
-            });
-        }
         if (scope === generated_1.EnvironmentVariableScope.Project) {
-            if (!environment) {
-                environment = await (0, prompts_2.promptVariableEnvironmentAsync)(nonInteractive);
-            }
             const existingVariables = await EnvironmentVariablesQuery_1.EnvironmentVariablesQuery.byAppIdAsync(graphqlClient, {
                 appId: projectId,
-                environment,
+                filterNames: [name],
             });
-            const existingVariable = existingVariables.find(variable => variable.name === name);
+            const existingVariable = existingVariables.find(variable => !environments || variable.environments?.some(env => environments?.includes(env)));
             if (existingVariable) {
+                if (existingVariable.scope === generated_1.EnvironmentVariableScope.Project) {
+                    await this.promptForOverwriteAsync({
+                        nonInteractive,
+                        force,
+                        message: `Variable ${name} already exists on this project.`,
+                        suggestion: 'Do you want to overwrite it?',
+                    });
+                    overwrite = true;
+                }
                 if (existingVariable.scope === generated_1.EnvironmentVariableScope.Shared) {
-                    if (!nonInteractive) {
-                        const confirmation = await (0, prompts_1.confirmAsync)({
-                            message: `Shared variable ${name} already exists on this project. Do you want to unlink it first?`,
-                        });
-                        if (!confirmation) {
-                            log_1.default.log('Aborting');
-                            throw new Error(`Shared variable ${name} already exists on this project.`);
-                        }
-                    }
-                    else if (!force) {
-                        throw new Error(`Shared variable ${name} already exists on this project. Use --force to overwrite it.`);
-                    }
-                    await EnvironmentVariableMutation_1.EnvironmentVariableMutation.unlinkSharedEnvironmentVariableAsync(graphqlClient, existingVariable.id, projectId, environment);
+                    await this.promptForOverwriteAsync({
+                        nonInteractive,
+                        force,
+                        message: `Shared variable with ${name} name already exists on this account.`,
+                        suggestion: 'Do you want to unlink it first?',
+                    });
                     log_1.default.withTick(`Unlinking shared variable ${chalk_1.default.bold(name)} on project ${chalk_1.default.bold(projectDisplayName)}.`);
-                }
-                else {
-                    if (!nonInteractive) {
-                        const confirmation = await (0, prompts_1.confirmAsync)({
-                            message: `Variable ${name} already exists on this project. Do you want to overwrite it?`,
-                        });
-                        if (!confirmation) {
-                            log_1.default.log('Aborting');
-                            throw new Error(`Variable ${name} already exists on this project.  Use --force to overwrite it.`);
-                        }
-                    }
-                    else if (!force) {
-                        throw new Error(`Variable ${name} already exists on this project. Use --force to overwrite it.`);
-                    }
-                    overwrite = true;
+                    await (0, variableUtils_1.performForEnvironmentsAsync)(environments, async (environment) => {
+                        await EnvironmentVariableMutation_1.EnvironmentVariableMutation.unlinkSharedEnvironmentVariableAsync(graphqlClient, existingVariable.id, projectId, environment);
+                    });
                 }
             }
-            const variable = await EnvironmentVariableMutation_1.EnvironmentVariableMutation.createForAppAsync(graphqlClient, {
-                name,
-                value,
-                environment,
-                visibility,
-                overwrite,
-            }, projectId);
+            const variable = overwrite && existingVariable
+                ? await EnvironmentVariableMutation_1.EnvironmentVariableMutation.updateAsync(graphqlClient, {
+                    id: existingVariable.id,
+                    name,
+                    value,
+                    visibility,
+                    environments,
+                    type,
+                })
+                : await EnvironmentVariableMutation_1.EnvironmentVariableMutation.createForAppAsync(graphqlClient, {
+                    name,
+                    value,
+                    environments,
+                    visibility,
+                    type: type ?? generated_1.EnvironmentSecretType.String,
+                }, projectId);
             if (!variable) {
                 throw new Error(`Could not create variable with name ${name} on project ${projectDisplayName}`);
             }
             log_1.default.withTick(`Created a new variable ${chalk_1.default.bold(name)} on project ${chalk_1.default.bold(projectDisplayName)}.`);
         }
         else if (scope === generated_1.EnvironmentVariableScope.Shared) {
-            const sharedVariables = await EnvironmentVariablesQuery_1.EnvironmentVariablesQuery.sharedAsync(graphqlClient, {
+            const existingVariables = await EnvironmentVariablesQuery_1.EnvironmentVariablesQuery.sharedAsync(graphqlClient, {
                 appId: projectId,
+                filterNames: [name],
             });
-            const existingVariable = sharedVariables.find(variable => variable.name === name);
+            const existingVariable = existingVariables.find(variable => !environments || variable.environments?.some(env => environments?.includes(env)));
             if (existingVariable) {
-                throw new Error(`Shared variable with ${name} name already exists on this account.\n` +
-                    `Use a different name or delete the existing variable  on website or by using eas env:delete --name ${name} --scope shared command.`);
-            }
-            if (environment && !link) {
-                const confirmation = await (0, prompts_1.confirmAsync)({
-                    message: `Unexpected argument: --environment can only be used with --link flag. Do you want to link the variable to the current project?`,
-                });
-                if (!confirmation) {
-                    log_1.default.log('Aborting');
-                    throw new Error('Unexpected argument: --environment can only be used with --link flag.');
+                if (force) {
+                    overwrite = true;
+                }
+                else {
+                    throw new Error(`Shared variable with ${name} name already exists on this account.\n` +
+                        `Use a different name or delete the existing variable on website or by using eas env:delete --name ${name} --scope shared command.`);
                 }
             }
-            if (!environment && link) {
-                environment = await (0, prompts_2.promptVariableEnvironmentAsync)(nonInteractive);
-            }
-            const variable = await EnvironmentVariableMutation_1.EnvironmentVariableMutation.createSharedVariableAsync(graphqlClient, {
-                name,
-                value,
-                visibility,
-            }, ownerAccount.id);
+            const variable = overwrite && existingVariable
+                ? await EnvironmentVariableMutation_1.EnvironmentVariableMutation.updateAsync(graphqlClient, {
+                    id: existingVariable.id,
+                    name,
+                    value,
+                    visibility,
+                    environments,
+                    type,
+                })
+                : await EnvironmentVariableMutation_1.EnvironmentVariableMutation.createSharedVariableAsync(graphqlClient, {
+                    name,
+                    value,
+                    visibility,
+                    environments,
+                    type: type ?? generated_1.EnvironmentSecretType.String,
+                }, ownerAccount.id);
             if (!variable) {
                 throw new Error(`Could not create variable with name ${name} on account ${ownerAccount.name}`);
             }
             log_1.default.withTick(`Created a new variable ${chalk_1.default.bold(name)} on account ${chalk_1.default.bold(ownerAccount.name)}.`);
-            if (link && environment) {
+            if (link) {
                 log_1.default.withTick(`Linking shared variable ${chalk_1.default.bold(name)} to project ${chalk_1.default.bold(projectDisplayName)}.`);
-                await EnvironmentVariableMutation_1.EnvironmentVariableMutation.linkSharedEnvironmentVariableAsync(graphqlClient, variable.id, projectId, environment);
+                await (0, variableUtils_1.performForEnvironmentsAsync)(environments, async (environment) => {
+                    await EnvironmentVariableMutation_1.EnvironmentVariableMutation.linkSharedEnvironmentVariableAsync(graphqlClient, variable.id, projectId, environment);
+                });
                 log_1.default.withTick(`Linked shared variable ${chalk_1.default.bold(name)} to project ${chalk_1.default.bold(projectDisplayName)}.`);
             }
         }
     }
+    async promptForOverwriteAsync({ nonInteractive, force, message, suggestion, }) {
+        if (!nonInteractive) {
+            const confirmation = await (0, prompts_1.confirmAsync)({
+                message: `${message} ${suggestion}`,
+            });
+            if (!confirmation) {
+                log_1.default.log('Aborting');
+                throw new Error(`${message}`);
+            }
+        }
+        else if (!force) {
+            throw new Error(`${message} Use --force to overwrite it.`);
+        }
+    }
+    async promptForMissingFlagsAsync({ name, value, environment, visibility = generated_1.EnvironmentVariableVisibility.Public, 'non-interactive': nonInteractive, type, ...rest }) {
+        if (!name) {
+            name = await (0, prompts_2.promptVariableNameAsync)(nonInteractive);
+        }
+        let newType;
+        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 (!value) {
+            value = await (0, prompts_2.promptVariableValueAsync)({
+                nonInteractive,
+                hidden: visibility !== generated_1.EnvironmentVariableVisibility.Public,
+            });
+        }
+        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 });
+        }
+        return {
+            name,
+            value,
+            environment,
+            visibility,
+            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`);
@@ -156,9 +211,13 @@ 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.EASEnvironmentFlag,
+    ...flags_1.EASMultiEnvironmentFlag,
     ...flags_1.EASNonInteractiveFlag,
 };
 EnvironmentVariableCreate.contextDefinition = {

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

@@ -5,9 +5,9 @@ export default class EnvironmentVariableDelete extends EasCommand {
     static hidden: boolean;
     static flags: {
         '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>;
-        name: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined>;
+        'variable-name': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined>;
+        'variable-environment': import("@oclif/core/lib/interfaces").OptionFlag<EnvironmentVariableEnvironment | undefined>;
     };
     static contextDefinition: {
         loggedIn: import("../../commandUtils/context/LoggedInContextField").default;

package/build/commands/env/delete.js

@@ -3,6 +3,7 @@ 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");
@@ -11,45 +12,52 @@ const EnvironmentVariableMutation_1 = require("../../graphql/mutations/Environme
 const EnvironmentVariablesQuery_1 = require("../../graphql/queries/EnvironmentVariablesQuery");
 const log_1 = tslib_1.__importDefault(require("../../log"));
 const prompts_1 = require("../../prompts");
-const prompts_2 = require("../../utils/prompts");
+const variableUtils_1 = require("../../utils/variableUtils");
 class EnvironmentVariableDelete extends EasCommand_1.default {
     async runAsync() {
         const { flags } = await this.parse(_a);
-        let { name, environment, 'non-interactive': nonInteractive, scope } = this.validateFlags(flags);
+        const { 'variable-name': name, 'variable-environment': environment, 'non-interactive': nonInteractive, scope, } = this.validateFlags(flags);
         const { privateProjectConfig: { projectId }, loggedIn: { graphqlClient }, } = await this.getContextAsync(_a, {
             nonInteractive,
         });
-        if (scope === generated_1.EnvironmentVariableScope.Project) {
-            if (!environment) {
-                environment = await (0, prompts_2.promptVariableEnvironmentAsync)(nonInteractive);
-            }
-        }
-        const variables = scope === generated_1.EnvironmentVariableScope.Project && environment
+        const variables = scope === generated_1.EnvironmentVariableScope.Project
             ? await EnvironmentVariablesQuery_1.EnvironmentVariablesQuery.byAppIdAsync(graphqlClient, {
                 appId: projectId,
                 environment,
             })
-            : await EnvironmentVariablesQuery_1.EnvironmentVariablesQuery.sharedAsync(graphqlClient, { appId: projectId });
+            : await EnvironmentVariablesQuery_1.EnvironmentVariablesQuery.sharedAsync(graphqlClient, {
+                appId: projectId,
+                environment,
+            });
+        let selectedVariable;
         if (!name) {
-            ({ name } = await (0, prompts_1.promptAsync)({
+            ({ variable: selectedVariable } = await (0, prompts_1.promptAsync)({
                 type: 'select',
-                name: 'name',
+                name: 'variable',
                 message: 'Pick the variable to be deleted:',
                 choices: variables
                     .filter(({ scope: variableScope }) => scope === variableScope)
-                    .map(variable => ({
-                    title: variable.name,
-                    value: variable.name,
-                })),
+                    .map(variable => {
+                    return {
+                        title: (0, variableUtils_1.formatVariableName)(variable),
+                        value: variable,
+                    };
+                }),
             }));
-            if (!name) {
-                throw new Error(`Environment variable wasn't selected. Run the command again and select existing variable or run it with ${chalk_1.default.bold('--name VARIABLE_NAME')} flag to fix the issue.`);
-            }
         }
-        const selectedVariable = variables.find(variable => variable.name === name);
-        if (!selectedVariable) {
-            throw new Error(`Variable "${name}" not found.`);
+        else {
+            const selectedVariables = variables.filter(variable => variable.name === name && (!environment || variable.environments?.includes(environment)));
+            if (selectedVariables.length !== 1) {
+                if (selectedVariables.length === 0) {
+                    throw new Error(`Variable "${name}" not found.`);
+                }
+                else {
+                    throw new Error(`Multiple variables with name "${name}" found. Please select the variable to delete interactively or run command with --variable-environment ENVIRONMENT option.`);
+                }
+            }
+            selectedVariable = selectedVariables[0];
         }
+        (0, assert_1.default)(selectedVariable, `Variable "${name}" not found.`);
         if (!nonInteractive) {
             log_1.default.addNewLineIfNone();
             log_1.default.warn(`You are about to permanently delete variable ${selectedVariable.name}.`);
@@ -62,7 +70,7 @@ class EnvironmentVariableDelete extends EasCommand_1.default {
             });
             if (!confirmed) {
                 log_1.default.error(`Canceled deletion of variable ${selectedVariable.name}.`);
-                throw new Error(`Variable "${name}" not deleted.`);
+                throw new Error(`Variable "${selectedVariable.name}" not deleted.`);
             }
         }
         await EnvironmentVariableMutation_1.EnvironmentVariableMutation.deleteAsync(graphqlClient, selectedVariable.id);
@@ -70,8 +78,8 @@ class EnvironmentVariableDelete extends EasCommand_1.default {
     }
     validateFlags(flags) {
         if (flags['non-interactive']) {
-            if (!flags.name) {
-                throw new Error(`Environment variable needs 'name' to be specified when running in non-interactive mode. Run the command with ${chalk_1.default.bold('--name VARIABLE_NAME')} flag to fix the issue`);
+            if (!flags['variable-name']) {
+                throw new Error(`Environment variable needs 'name' to be specified when running in non-interactive mode. Run the command with ${chalk_1.default.bold('--variable-name VARIABLE_NAME')} flag to fix the issue`);
             }
         }
         return flags;
@@ -81,11 +89,14 @@ _a = EnvironmentVariableDelete;
 EnvironmentVariableDelete.description = 'delete an environment variable by name';
 EnvironmentVariableDelete.hidden = true;
 EnvironmentVariableDelete.flags = {
-    name: core_1.Flags.string({
+    'variable-name': core_1.Flags.string({
         description: 'Name of the variable to delete',
     }),
+    'variable-environment': core_1.Flags.enum({
+        ...flags_1.EasEnvironmentFlagParameters,
+        description: 'Current environment of the variable to delete',
+    }),
     ...flags_1.EASVariableScopeFlag,
-    ...flags_1.EASEnvironmentFlag,
     ...flags_1.EASNonInteractiveFlag,
 };
 EnvironmentVariableDelete.contextDefinition = {

package/build/commands/env/exec.js

@@ -16,7 +16,8 @@ class EnvExec extends EasCommand_1.default {
         const { privateProjectConfig: { projectId }, loggedIn: { graphqlClient }, } = await this.getContextAsync(_a, {
             nonInteractive: parsedFlags.nonInteractive,
         });
-        const environment = parsedFlags.environment ?? (await (0, prompts_1.promptVariableEnvironmentAsync)(parsedFlags.nonInteractive));
+        const environment = parsedFlags.environment ??
+            (await (0, prompts_1.promptVariableEnvironmentAsync)({ nonInteractive: parsedFlags.nonInteractive }));
         const environmentVariables = await this.loadEnvironmentVariablesAsync({
             graphqlClient,
             projectId,

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

@@ -8,11 +8,11 @@ export default class EnvironmentVariableGet extends EasCommand {
         privateProjectConfig: import("../../commandUtils/context/PrivateProjectConfigContextField").PrivateProjectConfigContextField;
     };
     static flags: {
-        environment: import("@oclif/core/lib/interfaces").OptionFlag<EnvironmentVariableEnvironment | undefined>;
         'non-interactive': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
         scope: import("@oclif/core/lib/interfaces").OptionFlag<EnvironmentVariableScope>;
         format: import("@oclif/core/lib/interfaces").OptionFlag<string>;
-        name: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined>;
+        'variable-name': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined>;
+        'variable-environment': import("@oclif/core/lib/interfaces").OptionFlag<EnvironmentVariableEnvironment | undefined>;
     };
     runAsync(): Promise<void>;
     private validateFlags;

package/build/commands/env/get.js

@@ -3,54 +3,69 @@ 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");
 const generated_1 = require("../../graphql/generated");
 const EnvironmentVariablesQuery_1 = require("../../graphql/queries/EnvironmentVariablesQuery");
 const log_1 = tslib_1.__importDefault(require("../../log"));
-const formatVariable_1 = require("../../utils/formatVariable");
 const prompts_1 = require("../../utils/prompts");
+const variableUtils_1 = require("../../utils/variableUtils");
 class EnvironmentVariableGet extends EasCommand_1.default {
     async runAsync() {
         const { flags } = await this.parse(_a);
-        let { environment, name, 'non-interactive': nonInteractive, format, scope, } = this.validateFlags(flags);
+        let { 'variable-environment': environment, 'variable-name': name, 'non-interactive': nonInteractive, format, scope, } = this.validateFlags(flags);
         const { privateProjectConfig: { projectId }, loggedIn: { graphqlClient }, } = await this.getContextAsync(_a, {
             nonInteractive,
         });
         if (!name) {
             name = await (0, prompts_1.promptVariableNameAsync)(nonInteractive);
         }
-        if (!environment && scope === generated_1.EnvironmentVariableScope.Project) {
-            environment = await (0, prompts_1.promptVariableEnvironmentAsync)(nonInteractive);
-        }
-        const variable = await getVariableAsync(graphqlClient, scope, projectId, name, environment);
-        if (!variable) {
+        const variables = await getVariablesAsync(graphqlClient, scope, projectId, name, environment);
+        if (variables.length === 0) {
             log_1.default.error(`Variable with name "${name}" not found`);
             return;
         }
-        if (!variable.value) {
+        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}"`);
+            }
+            variable = variableInEnvironment;
+        }
+        else {
+            variable = variables[0];
+        }
+        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, formatVariable_1.formatVariable)(variable));
+            log_1.default.log((0, variableUtils_1.formatVariable)(variable));
         }
     }
     validateFlags(flags) {
-        if (flags.environment && flags.scope === generated_1.EnvironmentVariableScope.Shared) {
-            throw new Error(`Unexpected argument: --environment can only be used with project variables`);
-        }
         if (flags['non-interactive']) {
-            if (!flags.name) {
-                throw new Error('Variable name is required. Run the command with --name flag.');
+            if (!flags['variable-name']) {
+                throw new Error('Variable name is required. Run the command with --variable-name flag.');
             }
             if (!flags.scope) {
                 throw new Error('Scope is required. Run the command with --scope flag.');
             }
-            if (!flags.environment && flags.scope === generated_1.EnvironmentVariableScope.Project) {
+            if (!flags['variable-environment']) {
                 throw new Error('Environment is required.');
             }
         }
@@ -65,36 +80,37 @@ EnvironmentVariableGet.contextDefinition = {
     ..._a.ContextOptions.LoggedIn,
 };
 EnvironmentVariableGet.flags = {
-    name: core_1.Flags.string({
+    'variable-name': core_1.Flags.string({
         description: 'Name of the variable',
     }),
+    'variable-environment': core_1.Flags.enum({
+        ...flags_1.EasEnvironmentFlagParameters,
+        description: 'Current environment of the variable',
+    }),
     ...flags_1.EASVariableFormatFlag,
     ...flags_1.EASVariableScopeFlag,
     ...flags_1.EASNonInteractiveFlag,
-    ...flags_1.EASEnvironmentFlag,
 };
 exports.default = EnvironmentVariableGet;
-async function getVariableAsync(graphqlClient, scope, projectId, name, environment) {
-    if (!environment && scope === generated_1.EnvironmentVariableScope.Project) {
-        throw new Error('Environment is required.');
-    }
+async function getVariablesAsync(graphqlClient, scope, projectId, name, environment) {
     if (!name) {
-        throw new Error("Variable name is required. Run the command with '--name VARIABLE_NAME' flag.");
+        throw new Error("Variable name is required. Run the command with '--variable-name VARIABLE_NAME' flag.");
     }
-    if (environment && scope === generated_1.EnvironmentVariableScope.Project) {
+    if (scope === generated_1.EnvironmentVariableScope.Project) {
         const appVariables = await EnvironmentVariablesQuery_1.EnvironmentVariablesQuery.byAppIdWithSensitiveAsync(graphqlClient, {
             appId: projectId,
             environment,
             filterNames: [name],
+            includeFileContent: true,
         });
-        return appVariables[0];
+        return appVariables;
     }
-    if (scope === generated_1.EnvironmentVariableScope.Shared) {
+    else {
         const sharedVariables = await EnvironmentVariablesQuery_1.EnvironmentVariablesQuery.sharedWithSensitiveAsync(graphqlClient, {
             appId: projectId,
             filterNames: [name],
+            includeFileContent: true,
         });
-        return sharedVariables[0];
+        return sharedVariables;
     }
-    return null;
 }

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

@@ -1,11 +1,13 @@
 import EasCommand from '../../commandUtils/EasCommand';
+import { EnvironmentVariableEnvironment } from '../../graphql/generated';
 export default class EnvironmentVariableLink extends EasCommand {
     static description: string;
     static hidden: boolean;
     static flags: {
         'non-interactive': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
-        environment: import("@oclif/core/lib/interfaces").OptionFlag<import("../../graphql/generated").EnvironmentVariableEnvironment | undefined>;
-        name: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined>;
+        environment: import("@oclif/core/lib/interfaces").OptionFlag<EnvironmentVariableEnvironment[] | undefined>;
+        'variable-name': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined>;
+        'variable-environment': import("@oclif/core/lib/interfaces").OptionFlag<EnvironmentVariableEnvironment | undefined>;
     };
     static contextDefinition: {
         loggedIn: import("../../commandUtils/context/LoggedInContextField").default;