eas-cli 12.5.0 → 12.5.2

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.d.ts

@@ -0,0 +1,23 @@
+import EasCommand from '../../commandUtils/EasCommand';
+import { EnvironmentVariableEnvironment } from '../../graphql/generated';
+export default class EnvExec extends EasCommand {
+    static description: string;
+    static hidden: boolean;
+    static contextDefinition: {
+        loggedIn: import("../../commandUtils/context/LoggedInContextField").default;
+        privateProjectConfig: import("../../commandUtils/context/PrivateProjectConfigContextField").PrivateProjectConfigContextField;
+    };
+    static flags: {
+        'non-interactive': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        environment: import("@oclif/core/lib/interfaces").OptionFlag<EnvironmentVariableEnvironment | undefined>;
+    };
+    static args: {
+        name: string;
+        required: boolean;
+        description: string;
+    }[];
+    runAsync(): Promise<void>;
+    private sanitizeFlags;
+    private runCommandWithEnvVarsAsync;
+    private loadEnvironmentVariablesAsync;
+}

package/build/commands/env/exec.js

@@ -0,0 +1,125 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const spawn_async_1 = tslib_1.__importDefault(require("@expo/spawn-async"));
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const EasCommand_1 = tslib_1.__importDefault(require("../../commandUtils/EasCommand"));
+const flags_1 = require("../../commandUtils/flags");
+const EnvironmentVariablesQuery_1 = require("../../graphql/queries/EnvironmentVariablesQuery");
+const log_1 = tslib_1.__importDefault(require("../../log"));
+const prompts_1 = require("../../utils/prompts");
+class EnvExec extends EasCommand_1.default {
+    async runAsync() {
+        const { flags, args: { BASH_COMMAND: command }, } = await this.parse(_a);
+        const parsedFlags = this.sanitizeFlags(flags);
+        const { privateProjectConfig: { projectId }, loggedIn: { graphqlClient }, } = await this.getContextAsync(_a, {
+            nonInteractive: parsedFlags.nonInteractive,
+        });
+        const environment = parsedFlags.environment ??
+            (await (0, prompts_1.promptVariableEnvironmentAsync)({ nonInteractive: parsedFlags.nonInteractive }));
+        const environmentVariables = await this.loadEnvironmentVariablesAsync({
+            graphqlClient,
+            projectId,
+            environment,
+        });
+        await this.runCommandWithEnvVarsAsync({ command, environmentVariables });
+    }
+    sanitizeFlags(rawFlags) {
+        const environment = rawFlags.environment;
+        if (rawFlags['non-interactive']) {
+            if (!environment) {
+                throw new Error('You must specify an environment when running in non-interactive mode. Use the --environment flag.');
+            }
+            return {
+                nonInteractive: true,
+                environment,
+            };
+        }
+        return {
+            nonInteractive: false,
+            environment: rawFlags.environment,
+        };
+    }
+    async runCommandWithEnvVarsAsync({ command, environmentVariables, }) {
+        log_1.default.log(`Running command: ${chalk_1.default.bold(command)}`);
+        const spawnPromise = (0, spawn_async_1.default)('bash', ['-c', command], {
+            stdio: ['inherit', 'pipe', 'pipe'],
+            env: {
+                ...process.env,
+                ...environmentVariables,
+            },
+        });
+        const { child: { stdout, stderr }, } = spawnPromise;
+        if (!stdout || !stderr) {
+            throw new Error(`Failed to spawn ${command}`);
+        }
+        stdout.on('data', data => {
+            for (const line of data.toString().trim().split('\n')) {
+                log_1.default.log(`${chalk_1.default.gray('[stdout]')} ${line}`);
+            }
+        });
+        stderr.on('data', data => {
+            for (const line of data.toString().trim().split('\n')) {
+                log_1.default.warn(`${chalk_1.default.gray('[stderr]')} ${line}`);
+            }
+        });
+        try {
+            await spawnPromise;
+        }
+        catch (error) {
+            log_1.default.error(`❌ ${chalk_1.default.bold(command)} failed`);
+            throw error;
+        }
+    }
+    async loadEnvironmentVariablesAsync({ graphqlClient, projectId, environment, }) {
+        const environmentVariablesQueryResult = await EnvironmentVariablesQuery_1.EnvironmentVariablesQuery.byAppIdWithSensitiveAsync(graphqlClient, {
+            appId: projectId,
+            environment,
+        });
+        const secretEnvironmentVariables = environmentVariablesQueryResult.filter(({ value }) => !value);
+        if (secretEnvironmentVariables.length > 0) {
+            log_1.default.warn(`The following environment variables are secret and cannot be downloaded locally:`);
+            for (const { name } of secretEnvironmentVariables) {
+                log_1.default.warn(`- ${name}`);
+            }
+            log_1.default.warn('Proceeding with the rest of the environment variables.');
+            log_1.default.newLine();
+        }
+        const nonSecretEnvironmentVariables = environmentVariablesQueryResult.filter(({ value }) => !!value);
+        if (nonSecretEnvironmentVariables.length === 0) {
+            throw new Error('No readable environment variables found for the selected environment.');
+        }
+        log_1.default.log(`Loaded environment variables for the selected environment "${environment.toLowerCase()}":`);
+        for (const { name } of nonSecretEnvironmentVariables) {
+            log_1.default.log(`- ${name}`);
+        }
+        log_1.default.newLine();
+        const environmentVariables = {};
+        for (const { name, value } of nonSecretEnvironmentVariables) {
+            if (value) {
+                environmentVariables[name] = value;
+            }
+        }
+        return environmentVariables;
+    }
+}
+_a = EnvExec;
+EnvExec.description = 'execute a bash command with environment variables from the selected environment';
+EnvExec.hidden = true;
+EnvExec.contextDefinition = {
+    ..._a.ContextOptions.ProjectConfig,
+    ..._a.ContextOptions.LoggedIn,
+};
+EnvExec.flags = {
+    ...flags_1.EASEnvironmentFlag,
+    ...flags_1.EASNonInteractiveFlag,
+};
+EnvExec.args = [
+    {
+        name: 'BASH_COMMAND',
+        required: true,
+        description: 'bash command to execute with the environment variables from the environment',
+    },
+];
+exports.default = EnvExec;

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,32 +3,50 @@ 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;
         }
+        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.value) {
             throw new Error(`${chalk_1.default.bold(variable.name)} is a secret variable and cannot be displayed once it has been created.`);
         }
@@ -36,21 +54,18 @@ class EnvironmentVariableGet extends EasCommand_1.default {
             log_1.default.log(`${chalk_1.default.bold(variable.name)}=${variable.value}`);
         }
         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,35 @@ 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],
         });
-        return appVariables[0];
+        return appVariables;
     }
-    if (scope === generated_1.EnvironmentVariableScope.Shared) {
+    else {
         const sharedVariables = await EnvironmentVariablesQuery_1.EnvironmentVariablesQuery.sharedWithSensitiveAsync(graphqlClient, {
             appId: projectId,
             filterNames: [name],
         });
-        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;

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;
 }