eas-cli 10.2.2 → 10.2.4

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

@@ -0,0 +1,23 @@
+import EasCommand from '../../commandUtils/EasCommand';
+import { EnvironmentVariableEnvironment, EnvironmentVariableScope, EnvironmentVariableVisibility } from '../../graphql/generated';
+export default class EnvironmentVariableCreate 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<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>;
+    };
+    static contextDefinition: {
+        loggedIn: import("../../commandUtils/context/LoggedInContextField").default;
+        analytics: import("../../commandUtils/context/AnalyticsContextField").default;
+        privateProjectConfig: import("../../commandUtils/context/PrivateProjectConfigContextField").PrivateProjectConfigContextField;
+    };
+    runAsync(): Promise<void>;
+    private validateFlags;
+}

package/build/commands/env/create.js

@@ -0,0 +1,164 @@
+"use strict";
+var _a;
+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 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");
+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 { privateProjectConfig: { projectId }, loggedIn: { graphqlClient }, } = await this.getContextAsync(_a, {
+            nonInteractive,
+        });
+        const [projectDisplayName, ownerAccount] = await Promise.all([
+            (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, projectId, environment);
+            const existingVariable = existingVariables.find(variable => variable.name === name);
+            if (existingVariable) {
+                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);
+                    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;
+                }
+            }
+            const variable = await EnvironmentVariableMutation_1.EnvironmentVariableMutation.createForAppAsync(graphqlClient, {
+                name,
+                value,
+                environment,
+                visibility,
+                overwrite,
+            }, 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, projectId);
+            const existingVariable = sharedVariables.find(variable => variable.name === name);
+            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 (!environment && link) {
+                environment = await (0, prompts_2.promptVariableEnvironmentAsync)(nonInteractive);
+            }
+            const variable = await EnvironmentVariableMutation_1.EnvironmentVariableMutation.createSharedVariableAsync(graphqlClient, {
+                name,
+                value,
+                visibility,
+            }, 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) {
+                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);
+                log_1.default.withTick(`Linked shared variable ${chalk_1.default.bold(name)} to project ${chalk_1.default.bold(projectDisplayName)}.`);
+            }
+        }
+    }
+    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`);
+        }
+        if (flags.scope === generated_1.EnvironmentVariableScope.Shared &&
+            flags.environment &&
+            !flags.link &&
+            flags['non-interactive']) {
+            throw new Error('Unexpected argument: --environment in non-interactive mode can only be used with --link flag.');
+        }
+        return flags;
+    }
+}
+_a = EnvironmentVariableCreate;
+EnvironmentVariableCreate.description = 'create an environment variable on the current project or owner account';
+EnvironmentVariableCreate.hidden = true;
+EnvironmentVariableCreate.flags = {
+    name: core_1.Flags.string({
+        description: 'Name of the variable',
+    }),
+    value: core_1.Flags.string({
+        description: 'Text value or the variable',
+    }),
+    link: core_1.Flags.boolean({
+        description: 'Link shared variable to the current project',
+    }),
+    force: core_1.Flags.boolean({
+        description: 'Overwrite existing variable',
+        default: false,
+    }),
+    ...flags_1.EASVariableVisibilityFlag,
+    ...flags_1.EASVariableScopeFlag,
+    ...flags_1.EASEnvironmentFlag,
+    ...flags_1.EASNonInteractiveFlag,
+};
+EnvironmentVariableCreate.contextDefinition = {
+    ..._a.ContextOptions.ProjectConfig,
+    ..._a.ContextOptions.Analytics,
+    ..._a.ContextOptions.LoggedIn,
+};
+exports.default = EnvironmentVariableCreate;

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

@@ -0,0 +1,18 @@
+import EasCommand from '../../commandUtils/EasCommand';
+import { EnvironmentVariableEnvironment, EnvironmentVariableScope } from '../../graphql/generated';
+export default class EnvironmentVariableDelete 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<EnvironmentVariableEnvironment | undefined>;
+        scope: import("@oclif/core/lib/interfaces").OptionFlag<EnvironmentVariableScope>;
+        name: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined>;
+    };
+    static contextDefinition: {
+        loggedIn: import("../../commandUtils/context/LoggedInContextField").default;
+        privateProjectConfig: import("../../commandUtils/context/PrivateProjectConfigContextField").PrivateProjectConfigContextField;
+    };
+    runAsync(): Promise<void>;
+    private validateFlags;
+}

package/build/commands/env/delete.js

@@ -0,0 +1,92 @@
+"use strict";
+var _a;
+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 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 prompts_1 = require("../../prompts");
+const prompts_2 = require("../../utils/prompts");
+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 { 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
+            ? await EnvironmentVariablesQuery_1.EnvironmentVariablesQuery.byAppIdAsync(graphqlClient, projectId, environment)
+            : await EnvironmentVariablesQuery_1.EnvironmentVariablesQuery.sharedAsync(graphqlClient, projectId);
+        if (!name) {
+            ({ name } = await (0, prompts_1.promptAsync)({
+                type: 'select',
+                name: 'name',
+                message: 'Pick the variable to be deleted:',
+                choices: variables
+                    .filter(({ scope: variableScope }) => scope === variableScope)
+                    .map(variable => ({
+                    title: variable.name,
+                    value: variable.name,
+                })),
+            }));
+            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.`);
+        }
+        if (!nonInteractive) {
+            log_1.default.addNewLineIfNone();
+            log_1.default.warn(`You are about to permanently delete variable ${selectedVariable.name}.`);
+            log_1.default.warn('This action is irreversible.');
+            log_1.default.newLine();
+            const confirmed = await (0, prompts_1.toggleConfirmAsync)({
+                message: `Are you sure you wish to proceed?${selectedVariable.scope === generated_1.EnvironmentVariableScope.Shared
+                    ? ' This variable is applied across your whole account and may affect multiple apps.'
+                    : ''}`,
+            });
+            if (!confirmed) {
+                log_1.default.error(`Canceled deletion of variable ${selectedVariable.name}.`);
+                throw new Error(`Variable "${name}" not deleted.`);
+            }
+        }
+        await EnvironmentVariableMutation_1.EnvironmentVariableMutation.deleteAsync(graphqlClient, selectedVariable.id);
+        log_1.default.withTick(`️Deleted variable ${selectedVariable.name}".`);
+    }
+    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`);
+            }
+        }
+        return flags;
+    }
+}
+_a = EnvironmentVariableDelete;
+EnvironmentVariableDelete.description = 'delete an environment variable by name';
+EnvironmentVariableDelete.hidden = true;
+EnvironmentVariableDelete.flags = {
+    name: core_1.Flags.string({
+        description: 'Name of the variable to delete',
+    }),
+    ...flags_1.EASVariableScopeFlag,
+    ...flags_1.EASEnvironmentFlag,
+    ...flags_1.EASNonInteractiveFlag,
+};
+EnvironmentVariableDelete.contextDefinition = {
+    ..._a.ContextOptions.ProjectConfig,
+    ..._a.ContextOptions.LoggedIn,
+};
+exports.default = EnvironmentVariableDelete;

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

@@ -0,0 +1,19 @@
+import EasCommand from '../../commandUtils/EasCommand';
+import { EnvironmentVariableEnvironment, EnvironmentVariableScope } from '../../graphql/generated';
+export default class EnvironmentVariableGet extends EasCommand {
+    static description: string;
+    static hidden: boolean;
+    static contextDefinition: {
+        loggedIn: import("../../commandUtils/context/LoggedInContextField").default;
+        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>;
+    };
+    runAsync(): Promise<void>;
+    private validateFlags;
+}

package/build/commands/env/get.js

@@ -0,0 +1,92 @@
+"use strict";
+var _a;
+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 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");
+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);
+        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) {
+            log_1.default.error(`Variable with name "${name}" not found`);
+            return;
+        }
+        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.`);
+        }
+        if (format === 'short') {
+            log_1.default.log(`${chalk_1.default.bold(variable.name)}=${variable.value}`);
+        }
+        else {
+            log_1.default.log((0, formatVariable_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.scope) {
+                throw new Error('Scope is required. Run the command with --scope flag.');
+            }
+            if (!flags.environment && flags.scope === generated_1.EnvironmentVariableScope.Project) {
+                throw new Error('Environment is required.');
+            }
+        }
+        return flags;
+    }
+}
+_a = EnvironmentVariableGet;
+EnvironmentVariableGet.description = 'get environment variable';
+EnvironmentVariableGet.hidden = true;
+EnvironmentVariableGet.contextDefinition = {
+    ..._a.ContextOptions.ProjectConfig,
+    ..._a.ContextOptions.LoggedIn,
+};
+EnvironmentVariableGet.flags = {
+    name: core_1.Flags.string({
+        description: 'Name 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.');
+    }
+    if (environment && scope === generated_1.EnvironmentVariableScope.Project) {
+        const appVariables = await EnvironmentVariablesQuery_1.EnvironmentVariablesQuery.byAppIdAsync(graphqlClient, projectId, environment, [name]);
+        return appVariables[0];
+    }
+    if (scope === generated_1.EnvironmentVariableScope.Shared) {
+        const sharedVariables = await EnvironmentVariablesQuery_1.EnvironmentVariablesQuery.sharedAsync(graphqlClient, projectId, [
+            name,
+        ]);
+        return sharedVariables[0];
+    }
+    return null;
+}

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

@@ -0,0 +1,15 @@
+import EasCommand from '../../commandUtils/EasCommand';
+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>;
+    };
+    static contextDefinition: {
+        loggedIn: import("../../commandUtils/context/LoggedInContextField").default;
+        privateProjectConfig: import("../../commandUtils/context/PrivateProjectConfigContextField").PrivateProjectConfigContextField;
+    };
+    runAsync(): Promise<void>;
+}

package/build/commands/env/link.js

@@ -0,0 +1,57 @@
+"use strict";
+var _a;
+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 EasCommand_1 = tslib_1.__importDefault(require("../../commandUtils/EasCommand"));
+const flags_1 = require("../../commandUtils/flags");
+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");
+class EnvironmentVariableLink extends EasCommand_1.default {
+    async runAsync() {
+        let { flags: { name, 'non-interactive': nonInteractive, environment }, } = 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, projectId);
+        if (!name) {
+            name = await (0, prompts_1.selectAsync)('Select shared variable', variables.map(variable => ({
+                title: variable.name,
+                value: variable.name,
+            })));
+        }
+        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);
+        }
+        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}`);
+        }
+        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({
+        description: 'Name of the variable',
+    }),
+    ...flags_1.EASEnvironmentFlag,
+    ...flags_1.EASNonInteractiveFlag,
+};
+EnvironmentVariableLink.contextDefinition = {
+    ..._a.ContextOptions.ProjectConfig,
+    ..._a.ContextOptions.LoggedIn,
+};
+exports.default = EnvironmentVariableLink;

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

@@ -0,0 +1,16 @@
+import EasCommand from '../../commandUtils/EasCommand';
+import { EnvironmentVariableScope } from '../../graphql/generated';
+export default class EnvironmentValueList extends EasCommand {
+    static description: string;
+    static hidden: boolean;
+    static contextDefinition: {
+        loggedIn: import("../../commandUtils/context/LoggedInContextField").default;
+        privateProjectConfig: import("../../commandUtils/context/PrivateProjectConfigContextField").PrivateProjectConfigContextField;
+    };
+    static flags: {
+        environment: import("@oclif/core/lib/interfaces").OptionFlag<import("../../graphql/generated").EnvironmentVariableEnvironment | undefined>;
+        scope: import("@oclif/core/lib/interfaces").OptionFlag<EnvironmentVariableScope>;
+        format: import("@oclif/core/lib/interfaces").OptionFlag<string>;
+    };
+    runAsync(): Promise<void>;
+}

package/build/commands/env/list.js

@@ -0,0 +1,55 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+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");
+class EnvironmentValueList extends EasCommand_1.default {
+    async runAsync() {
+        let { flags: { environment, format, scope }, } = 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);
+        }
+        const variables = scope === generated_1.EnvironmentVariableScope.Project && environment
+            ? await EnvironmentVariablesQuery_1.EnvironmentVariablesQuery.byAppIdAsync(graphqlClient, projectId, environment)
+            : await EnvironmentVariablesQuery_1.EnvironmentVariablesQuery.sharedAsync(graphqlClient, 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.)"}`);
+            }
+        }
+        else {
+            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 for environment ${environment}:`));
+            }
+            log_1.default.log(variables.map(variable => (0, formatVariable_1.formatVariable)(variable)).join(`\n\n${chalk_1.default.dim('———')}\n\n`));
+        }
+    }
+}
+_a = EnvironmentValueList;
+EnvironmentValueList.description = 'list environment variables for the current project';
+EnvironmentValueList.hidden = true;
+EnvironmentValueList.contextDefinition = {
+    ..._a.ContextOptions.ProjectConfig,
+    ..._a.ContextOptions.LoggedIn,
+};
+EnvironmentValueList.flags = {
+    ...flags_1.EASVariableFormatFlag,
+    ...flags_1.EASVariableScopeFlag,
+    ...flags_1.EASEnvironmentFlag,
+};
+exports.default = EnvironmentValueList;

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

@@ -0,0 +1,15 @@
+import EasCommand from '../../commandUtils/EasCommand';
+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>;
+    };
+    static contextDefinition: {
+        loggedIn: import("../../commandUtils/context/LoggedInContextField").default;
+        privateProjectConfig: import("../../commandUtils/context/PrivateProjectConfigContextField").PrivateProjectConfigContextField;
+    };
+    runAsync(): Promise<void>;
+}

package/build/commands/env/unlink.js

@@ -0,0 +1,62 @@
+"use strict";
+var _a;
+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 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");
+class EnvironmentVariableUnlink extends EasCommand_1.default {
+    async runAsync() {
+        let { flags: { name, 'non-interactive': nonInteractive, environment }, } = 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, projectId, environment);
+        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,
+            })));
+        }
+        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}`);
+        }
+        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({
+        description: 'Name of the variable',
+    }),
+    ...flags_1.EASEnvironmentFlag,
+    ...flags_1.EASNonInteractiveFlag,
+};
+EnvironmentVariableUnlink.contextDefinition = {
+    ..._a.ContextOptions.ProjectConfig,
+    ..._a.ContextOptions.LoggedIn,
+};
+exports.default = EnvironmentVariableUnlink;