eas-cli 10.2.3 → 11.0.0

package/build/commands/env/delete.js

@@ -0,0 +1,95 @@
+"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, {
+                appId: projectId,
+                environment,
+            })
+            : await EnvironmentVariablesQuery_1.EnvironmentVariablesQuery.sharedAsync(graphqlClient, { appId: 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,100 @@
+"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 (!name) {
+        throw new Error("Variable name is required. Run the command with '--name VARIABLE_NAME' flag.");
+    }
+    if (environment && scope === generated_1.EnvironmentVariableScope.Project) {
+        const appVariables = await EnvironmentVariablesQuery_1.EnvironmentVariablesQuery.byAppIdWithSensitiveAsync(graphqlClient, {
+            appId: projectId,
+            environment,
+            filterNames: [name],
+        });
+        return appVariables[0];
+    }
+    if (scope === generated_1.EnvironmentVariableScope.Shared) {
+        const sharedVariables = await EnvironmentVariablesQuery_1.EnvironmentVariablesQuery.sharedWithSensitiveAsync(graphqlClient, {
+            appId: projectId,
+            filterNames: [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,59 @@
+"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, {
+            appId: 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,18 @@
+import EasCommand from '../../commandUtils/EasCommand';
+import { EnvironmentVariableEnvironment, 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<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

@@ -0,0 +1,82 @@
+"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 EnvironmentValueList extends EasCommand_1.default {
+    async runAsync() {
+        let { flags: { environment, format, scope, 'include-sensitive': includeSensitive }, } = 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 = 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.)"}`);
+            }
+        }
+        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`));
+        }
+    }
+    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,
+                });
+            }
+            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;
+EnvironmentValueList.description = 'list environment variables for the current project';
+EnvironmentValueList.hidden = true;
+EnvironmentValueList.contextDefinition = {
+    ..._a.ContextOptions.ProjectConfig,
+    ..._a.ContextOptions.LoggedIn,
+};
+EnvironmentValueList.flags = {
+    'include-sensitive': core_1.Flags.boolean({
+        description: 'Display sensitive values in the output',
+        default: false,
+    }),
+    ...flags_1.EASVariableFormatFlag,
+    ...flags_1.EASVariableScopeFlag,
+    ...flags_1.EASEnvironmentFlag,
+};
+exports.default = EnvironmentValueList;

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

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

package/build/commands/env/pull.js

@@ -0,0 +1,64 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const core_1 = require("@oclif/core");
+const fs = tslib_1.__importStar(require("fs-extra"));
+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("../../prompts");
+const prompts_2 = require("../../utils/prompts");
+class EnvironmentValuePull 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);
+        }
+        const { privateProjectConfig: { projectId }, loggedIn: { graphqlClient }, } = await this.getContextAsync(_a, {
+            nonInteractive,
+        });
+        targetPath = targetPath ?? '.env.local';
+        const environmentVariables = await EnvironmentVariablesQuery_1.EnvironmentVariablesQuery.byAppIdWithSensitiveAsync(graphqlClient, {
+            appId: projectId,
+            environment,
+        });
+        if (!nonInteractive && (await fs.exists(targetPath))) {
+            const result = await (0, prompts_1.confirmAsync)({
+                message: `File ${targetPath} already exists. Do you want to overwrite it?`,
+            });
+            if (!result) {
+                log_1.default.log('Aborting...');
+                throw new Error(`File ${targetPath} already exists.`);
+            }
+        }
+        const filePrefix = `# Environment: ${environment}\n\n`;
+        const envFileContent = environmentVariables
+            .map((variable) => {
+            if (variable.value === null) {
+                return `# ${variable.name}=***** (secret variables are not available for reading)`;
+            }
+            return `${variable.name}=${variable.value}`;
+        })
+            .join('\n');
+        await fs.writeFile(targetPath, filePrefix + envFileContent);
+        log_1.default.log(`Pulled environment variables from ${environment} environment to ${targetPath}.`);
+    }
+}
+_a = EnvironmentValuePull;
+EnvironmentValuePull.description = 'pull env file';
+EnvironmentValuePull.hidden = true;
+EnvironmentValuePull.contextDefinition = {
+    ..._a.ContextOptions.ProjectConfig,
+    ..._a.ContextOptions.LoggedIn,
+};
+EnvironmentValuePull.flags = {
+    ...flags_1.EASEnvironmentFlag,
+    ...flags_1.EASNonInteractiveFlag,
+    path: core_1.Flags.string({
+        description: 'Path to the result `.env` file',
+        default: '.env.local',
+    }),
+};
+exports.default = EnvironmentValuePull;

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

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

package/build/commands/env/push.js

@@ -0,0 +1,148 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const core_1 = require("@oclif/core");
+const dotenv_1 = tslib_1.__importDefault(require("dotenv"));
+const fs_extra_1 = tslib_1.__importDefault(require("fs-extra"));
+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");
+class EnvironmentVariablePush extends EasCommand_1.default {
+    async runAsync() {
+        const { flags } = await this.parse(_a);
+        const { environment, path: envPath } = this.validateFlags(flags);
+        const { privateProjectConfig: { projectId }, loggedIn: { graphqlClient }, } = await this.getContextAsync(_a, {
+            nonInteractive: false,
+        });
+        const updateVariables = await this.parseEnvFileAsync(envPath, environment);
+        const variableNames = Object.keys(updateVariables);
+        const existingVariables = await EnvironmentVariablesQuery_1.EnvironmentVariablesQuery.byAppIdAsync(graphqlClient, {
+            appId: projectId,
+            environment,
+            filterNames: variableNames,
+        });
+        const existingDifferentVariables = [];
+        // Remove variables that are the same as the ones in the environment
+        existingVariables.forEach(variable => {
+            const existingVariableUpdate = updateVariables[variable.name];
+            if (existingVariableUpdate && existingVariableUpdate.value !== variable.value) {
+                existingDifferentVariables.push(variable);
+            }
+            else {
+                delete updateVariables[variable.name];
+            }
+        });
+        const existingDifferentSharedVariables = existingDifferentVariables.filter(variable => variable.scope === generated_1.EnvironmentVariableScope.Shared);
+        if (existingDifferentSharedVariables.length > 0) {
+            const existingDifferentSharedVariablesNames = existingDifferentSharedVariables.map(variable => variable.name);
+            log_1.default.error('Shared variables cannot be overwritten by eas env:push command.');
+            log_1.default.error('Remove them from the env file or unlink them from the project to continue:');
+            existingDifferentSharedVariablesNames.forEach(name => {
+                log_1.default.error(`- ${name}`);
+            });
+            throw new Error('Shared variables cannot be overwritten by eas env:push command');
+        }
+        if (existingDifferentVariables.length > 0) {
+            log_1.default.warn('Some variables already exist in the environment.');
+            const variableNames = existingDifferentVariables.map(variable => variable.name);
+            const confirmationMessage = variableNames.length > 1
+                ? `The ${variableNames.join(', ')} environment variables already exist in ${environment} environment. Do you want to override them all?`
+                : `The ${variableNames[0]} environment variable already exists in ${environment} environment. Do you want to override it?`;
+            const confirm = await (0, prompts_1.confirmAsync)({
+                message: confirmationMessage,
+            });
+            let variablesToOverwrite = [];
+            if (!confirm && existingDifferentVariables.length === 1) {
+                throw new Error('No new variables to push.');
+            }
+            if (confirm) {
+                variablesToOverwrite = existingDifferentVariables.map(variable => variable.name);
+            }
+            else {
+                const promptResult = await (0, prompts_1.promptAsync)({
+                    type: 'multiselect',
+                    name: 'variablesToOverwrite',
+                    message: 'Select variables to overwrite:',
+                    // @ts-expect-error property missing from `@types/prompts`
+                    optionsPerPage: 20,
+                    choices: existingDifferentVariables.map(variable => ({
+                        title: `${variable.name}: ${updateVariables[variable.name].value} (was ${variable.value ?? '(secret)'})`,
+                        value: variable.name,
+                    })),
+                });
+                variablesToOverwrite = promptResult.variablesToOverwrite;
+            }
+            for (const existingVariable of existingVariables) {
+                const name = existingVariable.name;
+                if (variablesToOverwrite.includes(name)) {
+                    updateVariables[name]['overwrite'] = true;
+                }
+                else {
+                    delete updateVariables[name];
+                }
+            }
+        }
+        // Check if any of the sensitive variables already exist in the environment. Prompt the user to overwrite them.
+        const existingSensitiveVariables = existingVariables.filter(variable => variable.value === null);
+        if (existingSensitiveVariables.length > 0) {
+            const existingSensitiveVariablesNames = existingSensitiveVariables.map(variable => `- ${variable.name}`);
+            const confirm = await (0, prompts_1.confirmAsync)({
+                message: `You are about to overwrite sensitive variables.\n${existingSensitiveVariablesNames.join('\n')}\n Do you want to continue?`,
+            });
+            if (!confirm) {
+                throw new Error('Aborting...');
+            }
+        }
+        const variablesToPush = Object.values(updateVariables);
+        if (variablesToPush.length === 0) {
+            log_1.default.log('No new variables to push.');
+            return;
+        }
+        await EnvironmentVariableMutation_1.EnvironmentVariableMutation.createBulkEnvironmentVariablesForAppAsync(graphqlClient, variablesToPush, projectId);
+        log_1.default.log(`Uploaded env file to ${environment} environment.`);
+    }
+    async parseEnvFileAsync(envPath, environment) {
+        if (!(await fs_extra_1.default.exists(envPath))) {
+            throw new Error(`File ${envPath} does not exist.`);
+        }
+        const pushInput = {};
+        const variables = dotenv_1.default.parse(await fs_extra_1.default.readFile(envPath, 'utf8'));
+        for (const [name, value] of Object.entries(variables)) {
+            pushInput[name] = {
+                name,
+                value,
+                environment,
+                visibility: name.startsWith('EXPO_SENSITIVE')
+                    ? generated_1.EnvironmentVariableVisibility.Sensitive
+                    : generated_1.EnvironmentVariableVisibility.Public,
+            };
+        }
+        return pushInput;
+    }
+    validateFlags(flags) {
+        if (!flags.environment) {
+            throw new Error('Please provide an environment to push the env file to.');
+        }
+        return { ...flags, environment: flags.environment };
+    }
+}
+_a = EnvironmentVariablePush;
+EnvironmentVariablePush.description = 'push env file';
+EnvironmentVariablePush.hidden = true;
+EnvironmentVariablePush.contextDefinition = {
+    ..._a.ContextOptions.ProjectConfig,
+    ..._a.ContextOptions.LoggedIn,
+};
+EnvironmentVariablePush.flags = {
+    ...flags_1.EASEnvironmentFlag,
+    path: core_1.Flags.string({
+        description: 'Path to the input `.env` file',
+        default: '.env.local',
+    }),
+};
+exports.default = EnvironmentVariablePush;

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