eas-cli 12.5.1 → 12.5.2

package/build/commands/env/link.js

@@ -6,50 +6,89 @@ const core_1 = require("@oclif/core");
 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 EnvironmentVariableMutation_1 = require("../../graphql/mutations/EnvironmentVariableMutation");
 const EnvironmentVariablesQuery_1 = require("../../graphql/queries/EnvironmentVariablesQuery");
 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 EnvironmentVariableLink extends EasCommand_1.default {
     async runAsync() {
-        let { flags: { name, 'non-interactive': nonInteractive, environment }, } = await this.parse(_a);
+        let { flags: { 'variable-name': name, 'variable-environment': currentEnvironment, 'non-interactive': nonInteractive, environment: environments, }, } = await this.parse(_a);
         const { privateProjectConfig: { projectId }, loggedIn: { graphqlClient }, } = await this.getContextAsync(_a, {
             nonInteractive,
         });
         const projectDisplayName = await (0, projectUtils_1.getDisplayNameForProjectIdAsync)(graphqlClient, projectId);
         const variables = await EnvironmentVariablesQuery_1.EnvironmentVariablesQuery.sharedAsync(graphqlClient, {
             appId: projectId,
+            environment: currentEnvironment,
+            filterNames: name ? [name] : undefined,
         });
-        if (!name) {
-            name = await (0, prompts_1.selectAsync)('Select shared variable', variables.map(variable => ({
-                title: variable.name,
-                value: variable.name,
+        let selectedVariable = variables[0];
+        if (variables.length > 1) {
+            selectedVariable = await (0, prompts_1.selectAsync)('Select shared variable', variables.map(variable => ({
+                title: (0, variableUtils_1.formatVariableName)(variable),
+                value: variable,
             })));
         }
-        const selectedVariable = variables.find(variable => variable.name === name);
         if (!selectedVariable) {
             throw new Error(`Shared variable ${name} doesn't exist`);
         }
-        if (!environment) {
-            environment = await (0, prompts_2.promptVariableEnvironmentAsync)(nonInteractive);
+        let explicitSelect = false;
+        if (!nonInteractive && !environments) {
+            const selectedEnvironments = (selectedVariable.linkedEnvironments ?? []).length > 0
+                ? selectedVariable.linkedEnvironments
+                : selectedVariable.environments;
+            environments = await (0, prompts_2.promptVariableEnvironmentAsync)({
+                nonInteractive,
+                multiple: true,
+                selectedEnvironments: selectedEnvironments ?? [],
+            });
+            explicitSelect = true;
         }
-        const linkedVariable = await EnvironmentVariableMutation_1.EnvironmentVariableMutation.linkSharedEnvironmentVariableAsync(graphqlClient, selectedVariable.id, projectId, environment);
-        if (!linkedVariable) {
-            throw new Error(`Could not link variable with name ${selectedVariable.name} to project with id ${projectId}`);
+        if (!environments) {
+            await EnvironmentVariableMutation_1.EnvironmentVariableMutation.linkSharedEnvironmentVariableAsync(graphqlClient, selectedVariable.id, projectId);
+            log_1.default.withTick(`Linked variable ${chalk_1.default.bold(selectedVariable.name)} to project ${chalk_1.default.bold(projectDisplayName)} in ${selectedVariable.environments?.join(', ').toLocaleLowerCase()}.`);
+            return;
+        }
+        for (const environment of Object.values(generated_1.EnvironmentVariableEnvironment)) {
+            try {
+                if (selectedVariable.linkedEnvironments?.includes(environment) ===
+                    environments.includes(environment)) {
+                    if (!explicitSelect && environments.includes(environment)) {
+                        log_1.default.withTick(`Variable ${chalk_1.default.bold(selectedVariable.name)} is already linked to ${environment.toLocaleLowerCase()}.`);
+                    }
+                    continue;
+                }
+                if (environments.includes(environment)) {
+                    await EnvironmentVariableMutation_1.EnvironmentVariableMutation.linkSharedEnvironmentVariableAsync(graphqlClient, selectedVariable.id, projectId, environment);
+                    log_1.default.withTick(`Linked variable ${chalk_1.default.bold(selectedVariable.name)} to project ${chalk_1.default.bold(projectDisplayName)} in ${environment.toLocaleLowerCase()}.`);
+                }
+                else if (explicitSelect) {
+                    await EnvironmentVariableMutation_1.EnvironmentVariableMutation.unlinkSharedEnvironmentVariableAsync(graphqlClient, selectedVariable.id, projectId, environment);
+                    log_1.default.withTick(`Unlinked variable ${chalk_1.default.bold(selectedVariable.name)} from project ${chalk_1.default.bold(projectDisplayName)} in ${environment.toLocaleLowerCase()}.`);
+                }
+            }
+            catch (err) {
+                log_1.default.warn(err.message);
+            }
         }
-        log_1.default.withTick(`Linked variable ${chalk_1.default.bold(linkedVariable.name)} to project ${chalk_1.default.bold(projectDisplayName)}.`);
     }
 }
 _a = EnvironmentVariableLink;
 EnvironmentVariableLink.description = 'link a shared environment variable to the current project';
 EnvironmentVariableLink.hidden = true;
 EnvironmentVariableLink.flags = {
-    name: core_1.Flags.string({
+    'variable-name': core_1.Flags.string({
         description: 'Name of the variable',
     }),
-    ...flags_1.EASEnvironmentFlag,
+    'variable-environment': core_1.Flags.enum({
+        ...flags_1.EasEnvironmentFlagParameters,
+        description: 'Current environment of the variable to link',
+    }),
+    ...flags_1.EASMultiEnvironmentFlag,
     ...flags_1.EASNonInteractiveFlag,
 };
 EnvironmentVariableLink.contextDefinition = {

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

@@ -8,11 +8,10 @@ export default class EnvironmentValueList extends EasCommand {
         privateProjectConfig: import("../../commandUtils/context/PrivateProjectConfigContextField").PrivateProjectConfigContextField;
     };
     static flags: {
-        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>;
         format: import("@oclif/core/lib/interfaces").OptionFlag<string>;
         'include-sensitive': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
     };
     runAsync(): Promise<void>;
-    private getVariablesForScopeAsync;
 }

package/build/commands/env/list.js

@@ -9,58 +9,65 @@ 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");
+async function getVariablesForScopeAsync(graphqlClient, { scope, includingSensitive, environment, projectId, }) {
+    if (scope === generated_1.EnvironmentVariableScope.Project) {
+        if (includingSensitive) {
+            return await EnvironmentVariablesQuery_1.EnvironmentVariablesQuery.byAppIdWithSensitiveAsync(graphqlClient, {
+                appId: projectId,
+                environment,
+            });
+        }
+        return await EnvironmentVariablesQuery_1.EnvironmentVariablesQuery.byAppIdAsync(graphqlClient, {
+            appId: projectId,
+            environment,
+        });
+    }
+    return includingSensitive
+        ? await EnvironmentVariablesQuery_1.EnvironmentVariablesQuery.sharedWithSensitiveAsync(graphqlClient, {
+            appId: projectId,
+            environment,
+        })
+        : await EnvironmentVariablesQuery_1.EnvironmentVariablesQuery.sharedAsync(graphqlClient, { appId: projectId, environment });
+}
 class EnvironmentValueList extends EasCommand_1.default {
     async runAsync() {
-        let { flags: { environment, format, scope, 'include-sensitive': includeSensitive }, } = await this.parse(_a);
+        let { flags: { environment: environments, format, scope, 'include-sensitive': includeSensitive, 'non-interactive': nonInteractive, }, } = await this.parse(_a);
         const { privateProjectConfig: { projectId }, loggedIn: { graphqlClient }, } = await this.getContextAsync(_a, {
             nonInteractive: true,
         });
-        if (scope === generated_1.EnvironmentVariableScope.Project && !environment) {
-            environment = await (0, prompts_1.promptVariableEnvironmentAsync)(false);
+        if (!environments) {
+            environments = await (0, prompts_1.promptVariableEnvironmentAsync)({ nonInteractive, multiple: true });
         }
-        const variables = await this.getVariablesForScopeAsync(graphqlClient, {
-            scope,
-            includingSensitive: includeSensitive,
-            environment,
-            projectId,
-        });
-        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.)"}`);
+        await (0, variableUtils_1.performForEnvironmentsAsync)(environments, async (environment) => {
+            const variables = await getVariablesForScopeAsync(graphqlClient, {
+                scope,
+                includingSensitive: includeSensitive,
+                environment,
+                projectId,
+            });
+            log_1.default.addNewLineIfNone();
+            if (environment) {
+                log_1.default.log(chalk_1.default.bold(`Environment: ${environment}`));
             }
-        }
-        else {
-            if (scope === generated_1.EnvironmentVariableScope.Shared) {
-                log_1.default.log(chalk_1.default.bold('Shared variables for this account:'));
+            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.)"}`);
+                }
             }
             else {
-                log_1.default.log(chalk_1.default.bold(`Variables for this project for environment ${environment}:`));
-            }
-            log_1.default.log(variables.map(variable => (0, formatVariable_1.formatVariable)(variable)).join(`\n\n${chalk_1.default.dim('———')}\n\n`));
-        }
-    }
-    async getVariablesForScopeAsync(graphqlClient, { scope, includingSensitive, environment, projectId, }) {
-        if (scope === generated_1.EnvironmentVariableScope.Project && environment) {
-            if (includingSensitive) {
-                return await EnvironmentVariablesQuery_1.EnvironmentVariablesQuery.byAppIdWithSensitiveAsync(graphqlClient, {
-                    appId: projectId,
-                    environment,
-                });
+                if (scope === generated_1.EnvironmentVariableScope.Shared) {
+                    log_1.default.log(chalk_1.default.bold('Shared variables for this account:'));
+                }
+                else {
+                    log_1.default.log(chalk_1.default.bold(`Variables for this project:`));
+                }
+                log_1.default.log(variables.map(variable => (0, variableUtils_1.formatVariable)(variable)).join(`\n\n${chalk_1.default.dim('———')}\n\n`));
             }
-            return await EnvironmentVariablesQuery_1.EnvironmentVariablesQuery.byAppIdAsync(graphqlClient, {
-                appId: projectId,
-                environment,
-            });
-        }
-        return includingSensitive
-            ? await EnvironmentVariablesQuery_1.EnvironmentVariablesQuery.sharedWithSensitiveAsync(graphqlClient, {
-                appId: projectId,
-            })
-            : await EnvironmentVariablesQuery_1.EnvironmentVariablesQuery.sharedAsync(graphqlClient, { appId: projectId });
+        });
     }
 }
 _a = EnvironmentValueList;
@@ -77,6 +84,6 @@ EnvironmentValueList.flags = {
     }),
     ...flags_1.EASVariableFormatFlag,
     ...flags_1.EASVariableScopeFlag,
-    ...flags_1.EASEnvironmentFlag,
+    ...flags_1.EASMultiEnvironmentFlag,
 };
 exports.default = EnvironmentValueList;

package/build/commands/env/pull.js

@@ -14,7 +14,7 @@ class EnvironmentVariablePull extends EasCommand_1.default {
     async runAsync() {
         let { flags: { environment, path: targetPath, 'non-interactive': nonInteractive }, } = await this.parse(_a);
         if (!environment) {
-            environment = await (0, prompts_2.promptVariableEnvironmentAsync)(nonInteractive);
+            environment = await (0, prompts_2.promptVariableEnvironmentAsync)({ nonInteractive });
         }
         const { privateProjectConfig: { projectId }, loggedIn: { graphqlClient }, } = await this.getContextAsync(_a, {
             nonInteractive,

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

@@ -1,11 +1,12 @@
 import EasCommand from '../../commandUtils/EasCommand';
+import { EnvironmentVariableEnvironment } from '../../graphql/generated';
 export default class EnvironmentVariableUnlink 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>;
     };
     static contextDefinition: {
         loggedIn: import("../../commandUtils/context/LoggedInContextField").default;

package/build/commands/env/unlink.js

@@ -13,49 +13,76 @@ 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 EnvironmentVariableUnlink extends EasCommand_1.default {
     async runAsync() {
-        let { flags: { name, 'non-interactive': nonInteractive, environment }, } = await this.parse(_a);
+        let { flags: { 'variable-name': name, 'non-interactive': nonInteractive, environment: unlinkEnvironments, }, } = await this.parse(_a);
         const { privateProjectConfig: { projectId }, loggedIn: { graphqlClient }, } = await this.getContextAsync(_a, {
             nonInteractive,
         });
-        if (!environment) {
-            environment = await (0, prompts_2.promptVariableEnvironmentAsync)(nonInteractive);
-        }
         const projectDisplayName = await (0, projectUtils_1.getDisplayNameForProjectIdAsync)(graphqlClient, projectId);
-        const appVariables = await EnvironmentVariablesQuery_1.EnvironmentVariablesQuery.byAppIdAsync(graphqlClient, {
+        const variables = await EnvironmentVariablesQuery_1.EnvironmentVariablesQuery.sharedAsync(graphqlClient, {
             appId: projectId,
-            environment,
+            filterNames: name ? [name] : undefined,
         });
-        const linkedVariables = appVariables.filter(({ scope }) => scope === generated_1.EnvironmentVariableScope.Shared);
-        if (linkedVariables.length === 0) {
-            throw new Error(`There are no linked shared env variables for project ${projectDisplayName}`);
-        }
-        if (!name) {
-            name = await (0, prompts_1.selectAsync)('Select shared variable to unlink', linkedVariables.map(variable => ({
-                title: variable.name,
-                value: variable.name,
+        let selectedVariable = variables[0];
+        if (variables.length > 1) {
+            if (nonInteractive) {
+                throw new Error("Multiple variables found, please select one using '--variable-name'");
+            }
+            selectedVariable = await (0, prompts_1.selectAsync)('Select shared variable', variables.map(variable => ({
+                title: (0, variableUtils_1.formatVariableName)(variable),
+                value: variable,
             })));
         }
-        const selectedVariable = linkedVariables.find(variable => variable.name === name);
         if (!selectedVariable) {
             throw new Error(`Shared variable ${name} doesn't exist`);
         }
-        const unlinkedVariable = await EnvironmentVariableMutation_1.EnvironmentVariableMutation.unlinkSharedEnvironmentVariableAsync(graphqlClient, selectedVariable.id, projectId, environment);
-        if (!unlinkedVariable) {
-            throw new Error(`Could not unlink variable with name ${selectedVariable.name} from project ${projectDisplayName}`);
+        let explicitSelect = false;
+        if (!nonInteractive && !unlinkEnvironments) {
+            const selectedEnvironments = (selectedVariable.linkedEnvironments ?? []).length > 0
+                ? selectedVariable.linkedEnvironments
+                : selectedVariable.environments;
+            const environments = await (0, prompts_2.promptVariableEnvironmentAsync)({
+                nonInteractive,
+                multiple: true,
+                selectedEnvironments: selectedEnvironments ?? [],
+            });
+            explicitSelect = true;
+            unlinkEnvironments = Object.values(generated_1.EnvironmentVariableEnvironment).filter(env => !environments.includes(env));
+        }
+        if (!unlinkEnvironments) {
+            await EnvironmentVariableMutation_1.EnvironmentVariableMutation.unlinkSharedEnvironmentVariableAsync(graphqlClient, selectedVariable.id, projectId);
+            log_1.default.withTick(`Unlinked variable ${chalk_1.default.bold(selectedVariable.name)} from project ${chalk_1.default.bold(projectDisplayName)} in ${selectedVariable.environments?.join(', ').toLocaleLowerCase()}.`);
+            return;
+        }
+        for (const environment of Object.values(generated_1.EnvironmentVariableEnvironment)) {
+            if (selectedVariable.linkedEnvironments?.includes(environment) !==
+                unlinkEnvironments.includes(environment)) {
+                if (!explicitSelect && unlinkEnvironments.includes(environment)) {
+                    log_1.default.withTick(`Variable ${chalk_1.default.bold(selectedVariable.name)} is already unlinked from ${environment.toLocaleLowerCase()}.`);
+                }
+                continue;
+            }
+            if (unlinkEnvironments.includes(environment)) {
+                await EnvironmentVariableMutation_1.EnvironmentVariableMutation.unlinkSharedEnvironmentVariableAsync(graphqlClient, selectedVariable.id, projectId, environment);
+                log_1.default.withTick(`Unlinked variable ${chalk_1.default.bold(selectedVariable.name)} from project ${chalk_1.default.bold(projectDisplayName)} in ${environment.toLocaleLowerCase()}.`);
+            }
+            else if (explicitSelect) {
+                await EnvironmentVariableMutation_1.EnvironmentVariableMutation.linkSharedEnvironmentVariableAsync(graphqlClient, selectedVariable.id, projectId, environment);
+                log_1.default.withTick(`Linked variable ${chalk_1.default.bold(selectedVariable.name)} to project ${chalk_1.default.bold(projectDisplayName)} in ${environment.toLocaleLowerCase()}.`);
+            }
         }
-        log_1.default.withTick(`Unlinked variable ${chalk_1.default.bold(unlinkedVariable.name)} from the project ${chalk_1.default.bold(projectDisplayName)}.`);
     }
 }
 _a = EnvironmentVariableUnlink;
 EnvironmentVariableUnlink.description = 'unlink a shared environment variable to the current project';
 EnvironmentVariableUnlink.hidden = true;
 EnvironmentVariableUnlink.flags = {
-    name: core_1.Flags.string({
+    'variable-name': core_1.Flags.string({
         description: 'Name of the variable',
     }),
-    ...flags_1.EASEnvironmentFlag,
+    ...flags_1.EASMultiEnvironmentFlag,
     ...flags_1.EASNonInteractiveFlag,
 };
 EnvironmentVariableUnlink.contextDefinition = {

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

@@ -1,13 +1,15 @@
 import EasCommand from '../../commandUtils/EasCommand';
-import { EnvironmentVariableScope, EnvironmentVariableVisibility } from '../../graphql/generated';
+import { EnvironmentVariableEnvironment, EnvironmentVariableScope, EnvironmentVariableVisibility } from '../../graphql/generated';
 export default class EnvironmentVariableUpdate 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>;
+        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>;
+        '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>;
     };

package/build/commands/env/update.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");
@@ -13,10 +14,11 @@ 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 EnvironmentVariableUpdate extends EasCommand_1.default {
     async runAsync() {
         const { flags } = await this.parse(_a);
-        let { name, value, scope, 'non-interactive': nonInteractive, environment, visibility, } = this.validateFlags(flags);
+        let { name, value, scope, 'variable-name': currentName, 'variable-environment': currentEnvironment, 'non-interactive': nonInteractive, environment: environments, visibility, } = this.validateFlags(flags);
         const { privateProjectConfig: { projectId }, loggedIn: { graphqlClient }, } = await this.getContextAsync(_a, {
             nonInteractive,
         });
@@ -24,89 +26,82 @@ class EnvironmentVariableUpdate extends EasCommand_1.default {
             (0, projectUtils_1.getDisplayNameForProjectIdAsync)(graphqlClient, projectId),
             (0, projectUtils_1.getOwnerAccountForProjectIdAsync)(graphqlClient, projectId),
         ]);
+        let selectedVariable;
+        let existingVariables = [];
+        const suffix = scope === generated_1.EnvironmentVariableScope.Project
+            ? `on project ${projectDisplayName}`
+            : `on account ${ownerAccount.name}`;
         if (scope === generated_1.EnvironmentVariableScope.Project) {
-            if (!environment) {
-                environment = await (0, prompts_2.promptVariableEnvironmentAsync)(nonInteractive);
-            }
-            const existingVariables = await EnvironmentVariablesQuery_1.EnvironmentVariablesQuery.byAppIdAsync(graphqlClient, {
+            existingVariables = await EnvironmentVariablesQuery_1.EnvironmentVariablesQuery.byAppIdAsync(graphqlClient, {
                 appId: projectId,
-                environment,
+                environment: currentEnvironment,
+                filterNames: currentName ? [currentName] : undefined,
             });
-            if (!name) {
-                name = await (0, prompts_1.selectAsync)('Select variable', existingVariables.map(variable => ({
-                    title: variable.name,
-                    value: variable.name,
-                })));
-            }
-            const existingVariable = existingVariables.find(variable => variable.name === name);
-            if (!existingVariable) {
-                throw new Error(`Variable with name ${name} does not exist on project ${projectDisplayName}`);
-            }
-            if (!value) {
-                value = await (0, prompts_2.promptVariableValueAsync)({
-                    nonInteractive,
-                    required: false,
-                    initial: existingVariable.value,
-                });
-                if (!value || value.length === 0) {
-                    value = '';
-                }
-            }
-            const variable = await EnvironmentVariableMutation_1.EnvironmentVariableMutation.createForAppAsync(graphqlClient, {
-                name,
-                value,
-                environment,
-                visibility,
-                overwrite: true,
-            }, projectId);
-            if (!variable) {
-                throw new Error(`Could not update variable with name ${name} on project ${projectDisplayName}`);
-            }
-            log_1.default.withTick(`Updated 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, {
+        if (scope === generated_1.EnvironmentVariableScope.Shared) {
+            existingVariables = await EnvironmentVariablesQuery_1.EnvironmentVariablesQuery.sharedAsync(graphqlClient, {
                 appId: projectId,
+                environment: currentEnvironment,
+                filterNames: currentName ? [currentName] : undefined,
             });
+        }
+        if (existingVariables.length === 0) {
+            throw new Error(`Variable with name ${currentName} ${currentEnvironment ? `in environment ${currentEnvironment}` : ''} does not exist ${suffix}.`);
+        }
+        else if (existingVariables.length > 1) {
+            selectedVariable = await (0, prompts_1.selectAsync)('Select variable', existingVariables.map(variable => ({
+                title: (0, variableUtils_1.formatVariableName)(variable),
+                value: variable,
+            })));
+        }
+        else {
+            selectedVariable = existingVariables[0];
+        }
+        (0, assert_1.default)(selectedVariable, 'Variable must be selected');
+        if (!nonInteractive) {
             if (!name) {
-                name = await (0, prompts_1.selectAsync)('Select variable', sharedVariables.map(variable => ({
-                    title: variable.name,
-                    value: variable.name,
-                })));
-            }
-            const existingVariable = sharedVariables.find(variable => variable.name === name);
-            if (!existingVariable) {
-                throw new Error("Variable with this name  doesn't exist on this account. Use a different name.");
+                name = await (0, prompts_2.promptVariableNameAsync)(nonInteractive, selectedVariable.name);
+                if (!name || name.length === 0) {
+                    name = undefined;
+                }
             }
             if (!value) {
                 value = await (0, prompts_2.promptVariableValueAsync)({
                     nonInteractive,
                     required: false,
-                    initial: existingVariable.value,
+                    initial: selectedVariable.value,
                 });
                 if (!value || value.length === 0) {
-                    value = '';
+                    value = undefined;
                 }
             }
-            const variable = await EnvironmentVariableMutation_1.EnvironmentVariableMutation.createSharedVariableAsync(graphqlClient, {
-                name,
-                value,
-                visibility,
-                overwrite: true,
-            }, ownerAccount.id);
-            if (!variable) {
-                throw new Error(`Could not update variable with name ${name} on account ${ownerAccount.name}`);
+            if (!environments || environments.length === 0) {
+                environments = await (0, prompts_2.promptVariableEnvironmentAsync)({
+                    nonInteractive,
+                    multiple: true,
+                    selectedEnvironments: selectedVariable.environments ?? [],
+                });
             }
-            log_1.default.withTick(`Updated shared variable ${chalk_1.default.bold(name)} on account ${chalk_1.default.bold(ownerAccount.name)}.`);
+            if (!visibility) {
+                visibility = await (0, prompts_2.promptVariableVisibilityAsync)(nonInteractive, selectedVariable.visibility);
+            }
+        }
+        const variable = await EnvironmentVariableMutation_1.EnvironmentVariableMutation.updateAsync(graphqlClient, {
+            id: selectedVariable.id,
+            name,
+            value,
+            environments,
+            visibility,
+        });
+        if (!variable) {
+            throw new Error(`Could not update variable with name ${name} ${suffix}`);
         }
+        log_1.default.withTick(`Updated variable ${chalk_1.default.bold(selectedVariable.name)} ${suffix}.`);
     }
     validateFlags(flags) {
         if (flags['non-interactive']) {
-            if (!flags.name) {
-                throw new Error('Variable name is required in non-interactive mode. Run the command with --name flag.');
-            }
-            if (flags.scope === generated_1.EnvironmentVariableScope.Project && !flags.environment) {
-                throw new Error('Environment is required when updating project-wide variable in non-interactive mode. Run the command with --environment flag.');
+            if (!flags['variable-name']) {
+                throw new Error('Current name is required in non-interactive mode. Run the command with --variable-name flag.');
             }
         }
         return flags;
@@ -116,15 +111,22 @@ _a = EnvironmentVariableUpdate;
 EnvironmentVariableUpdate.description = 'update an environment variable on the current project or owner account';
 EnvironmentVariableUpdate.hidden = true;
 EnvironmentVariableUpdate.flags = {
+    'variable-name': core_1.Flags.string({
+        description: 'Current name of the variable',
+    }),
+    'variable-environment': core_1.Flags.enum({
+        ...flags_1.EasEnvironmentFlagParameters,
+        description: 'Current environment of the variable to update',
+    }),
     name: core_1.Flags.string({
-        description: 'Name of the variable',
+        description: 'New name of the variable',
     }),
     value: core_1.Flags.string({
-        description: 'Text value or the variable',
+        description: 'New value or the variable',
     }),
     ...flags_1.EASVariableVisibilityFlag,
     ...flags_1.EASVariableScopeFlag,
-    ...flags_1.EASEnvironmentFlag,
+    ...flags_1.EASMultiEnvironmentFlag,
     ...flags_1.EASNonInteractiveFlag,
 };
 EnvironmentVariableUpdate.contextDefinition = {

package/build/commands/update/index.js

@@ -426,7 +426,6 @@ UpdatePublish.flags = {
     'rollout-percentage': core_1.Flags.integer({
         description: `Percentage of users this update should be immediately available to. Users not in the rollout will be served the previous latest update on the branch, even if that update is itself being rolled out. The specified number must be an integer between 1 and 100. When not specified, this defaults to 100.`,
         required: false,
-        hidden: true,
         min: 0,
         max: 100,
     }),