@donotuse/eas-cli 18.5.0-rc.1

package/build/commands/env/get.js

@@ -0,0 +1,130 @@
+"use strict";
+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 prompts_1 = require("../../utils/prompts");
+const variableUtils_1 = require("../../utils/variableUtils");
+class EnvGet extends EasCommand_1.default {
+    static description = 'view an environment variable for the current project or account';
+    static contextDefinition = {
+        ...this.ContextOptions.ProjectId,
+        ...this.ContextOptions.LoggedIn,
+    };
+    static args = {
+        environment: core_1.Args.string({
+            description: "Current environment of the variable. Default environments are 'production', 'preview', and 'development'.",
+            required: false,
+        }),
+    };
+    static flags = {
+        'variable-name': core_1.Flags.string({
+            description: 'Name of the variable',
+        }),
+        'variable-environment': core_1.Flags.string({
+            ...flags_1.EasEnvironmentFlagParameters,
+            description: 'Current environment of the variable',
+        }),
+        ...flags_1.EASVariableFormatFlag,
+        ...flags_1.EASEnvironmentVariableScopeFlag,
+        ...flags_1.EASNonInteractiveFlag,
+    };
+    async runAsync() {
+        const { args, flags } = await this.parse(EnvGet);
+        let { 'variable-environment': environment, 'variable-name': name, 'non-interactive': nonInteractive, format, scope, } = this.sanitizeInputs(flags, args);
+        const { projectId, loggedIn: { graphqlClient }, } = await this.getContextAsync(EnvGet, {
+            nonInteractive,
+        });
+        if (!name) {
+            name = await (0, prompts_1.promptVariableNameAsync)(nonInteractive);
+        }
+        if (!environment) {
+            environment = await (0, prompts_1.promptVariableEnvironmentAsync)({
+                nonInteractive,
+                multiple: false,
+                graphqlClient,
+                projectId,
+            });
+        }
+        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) {
+            const variableInEnvironment = variables.find(v => v.environments?.includes(environment));
+            if (!variableInEnvironment) {
+                throw new Error(`Variable with name "${name}" not found in environment "${environment.toLocaleLowerCase()}"`);
+            }
+            variable = variableInEnvironment;
+        }
+        else {
+            variable = variables[0];
+        }
+        if (variable.visibility === generated_1.EnvironmentVariableVisibility.Secret) {
+            throw new Error(`${chalk_1.default.bold(variable.name)} is a secret variable and cannot be displayed once it has been created.`);
+        }
+        if (format === 'short') {
+            log_1.default.log(`${chalk_1.default.bold(variable.name)}=${(0, variableUtils_1.formatVariableValue)(variable)}`);
+        }
+        else {
+            log_1.default.log((0, variableUtils_1.formatVariable)(variable));
+        }
+    }
+    sanitizeInputs(flags, { environment }) {
+        if (flags['non-interactive']) {
+            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['variable-environment'] ?? environment)) {
+                throw new Error('Environment is required.');
+            }
+        }
+        if (environment && flags['variable-environment']) {
+            throw new Error("You can't use both --variable-environment flag when environment is passed as an argument. Run `eas env:get --help` for more information.");
+        }
+        const scope = flags.scope === 'account'
+            ? generated_1.EnvironmentVariableScope.Shared
+            : generated_1.EnvironmentVariableScope.Project;
+        if (environment) {
+            return {
+                ...flags,
+                'variable-environment': environment,
+                scope,
+            };
+        }
+        return { ...flags, scope };
+    }
+}
+exports.default = EnvGet;
+async function getVariablesAsync(graphqlClient, scope, projectId, name, environment) {
+    if (!name) {
+        throw new Error("Variable name is required. Run the command with '--variable-name VARIABLE_NAME' flag.");
+    }
+    if (scope === generated_1.EnvironmentVariableScope.Project) {
+        const appVariables = await EnvironmentVariablesQuery_1.EnvironmentVariablesQuery.byAppIdWithSensitiveAsync(graphqlClient, {
+            appId: projectId,
+            environment,
+            filterNames: [name],
+            includeFileContent: true,
+        });
+        return appVariables;
+    }
+    else {
+        const sharedVariables = await EnvironmentVariablesQuery_1.EnvironmentVariablesQuery.sharedWithSensitiveAsync(graphqlClient, {
+            appId: projectId,
+            filterNames: [name],
+            includeFileContent: true,
+        });
+        return sharedVariables;
+    }
+}

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

@@ -0,0 +1,23 @@
+import EasCommand from '../../commandUtils/EasCommand';
+import { EnvironmentVariableEnvironment } from '../../graphql/generated';
+export default class EnvLink 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>;
+        'variable-name': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined>;
+        'variable-environment': import("@oclif/core/lib/interfaces").OptionFlag<EnvironmentVariableEnvironment | undefined>;
+    };
+    static args: {
+        name: string;
+        description: string;
+        required: boolean;
+    }[];
+    static contextDefinition: {
+        loggedIn: import("../../commandUtils/context/LoggedInContextField").default;
+        projectId: import("../../commandUtils/context/ProjectIdContextField").ProjectIdContextField;
+    };
+    runAsync(): Promise<void>;
+    private validateInputs;
+}

package/build/commands/env/link.js

@@ -0,0 +1,128 @@
+"use strict";
+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");
+const variableUtils_1 = require("../../utils/variableUtils");
+class EnvLink extends EasCommand_1.default {
+    static description = 'link an account-wide environment variable to the current project';
+    // for now we only roll out global account-wide env variables so this should stay hidden
+    static hidden = true;
+    static flags = {
+        '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 to link',
+        }),
+        ...flags_1.EASMultiEnvironmentFlag,
+        ...flags_1.EASNonInteractiveFlag,
+    };
+    static args = [
+        {
+            name: 'environment',
+            description: "Environment to pull variables from. One of 'production', 'preview', or 'development'.",
+            required: false,
+        },
+    ];
+    static contextDefinition = {
+        ...this.ContextOptions.ProjectId,
+        ...this.ContextOptions.LoggedIn,
+    };
+    async runAsync() {
+        const { args, flags } = await this.parse(EnvLink);
+        let { 'variable-name': name, 'variable-environment': currentEnvironment, 'non-interactive': nonInteractive, environment: environments, } = this.validateInputs(flags, args);
+        const { projectId, loggedIn: { graphqlClient }, } = await this.getContextAsync(EnvLink, {
+            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,
+        });
+        let selectedVariable = variables[0];
+        if (variables.length > 1) {
+            if (nonInteractive) {
+                throw new Error('Multiple variables found, run command with --variable-name and --variable-environment arguments.');
+            }
+            selectedVariable = await (0, prompts_1.selectAsync)('Select account-wide variable', variables.map(variable => ({
+                title: (0, variableUtils_1.formatVariableName)(variable),
+                value: variable,
+            })));
+        }
+        if (!selectedVariable) {
+            throw new Error(`Account-wide variable ${name} doesn't exist`);
+        }
+        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;
+        }
+        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);
+            }
+        }
+    }
+    validateInputs(flags, { environment }) {
+        environment = environment?.toUpperCase();
+        if (environment && !(0, variableUtils_1.isEnvironment)(environment)) {
+            throw new Error("Invalid environment. Use one of 'production', 'preview', or 'development'.");
+        }
+        const environments = flags.environment
+            ? flags.environment
+            : environment
+                ? [environment]
+                : undefined;
+        if (flags['non-interactive']) {
+            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,
+            environment: environments,
+        };
+    }
+}
+exports.default = EnvLink;

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

@@ -0,0 +1,20 @@
+import EasCommand from '../../commandUtils/EasCommand';
+export default class EnvList extends EasCommand {
+    static description: string;
+    static contextDefinition: {
+        loggedIn: import("../../commandUtils/context/LoggedInContextField").default;
+        projectId: import("../../commandUtils/context/ProjectIdContextField").ProjectIdContextField;
+    };
+    static flags: {
+        scope: import("@oclif/core/lib/interfaces").OptionFlag<"project" | "account", import("@oclif/core/lib/interfaces").CustomOptions>;
+        format: import("@oclif/core/lib/interfaces").OptionFlag<"long" | "short", import("@oclif/core/lib/interfaces").CustomOptions>;
+        environment: import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'include-sensitive': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        'include-file-content': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    static args: {
+        environment: import("@oclif/core/lib/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    runAsync(): Promise<void>;
+    private sanitizeInputs;
+}

package/build/commands/env/list.js

@@ -0,0 +1,123 @@
+"use strict";
+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 prompts_1 = require("../../utils/prompts");
+const variableUtils_1 = require("../../utils/variableUtils");
+async function getVariablesForScopeAsync(graphqlClient, { scope, includingSensitive, includeFileContent, environment, projectId, }) {
+    if (scope === generated_1.EnvironmentVariableScope.Project) {
+        if (includingSensitive) {
+            return await EnvironmentVariablesQuery_1.EnvironmentVariablesQuery.byAppIdWithSensitiveAsync(graphqlClient, {
+                appId: projectId,
+                environment,
+                includeFileContent,
+            });
+        }
+        return await EnvironmentVariablesQuery_1.EnvironmentVariablesQuery.byAppIdAsync(graphqlClient, {
+            appId: projectId,
+            environment,
+            includeFileContent,
+        });
+    }
+    return includingSensitive
+        ? await EnvironmentVariablesQuery_1.EnvironmentVariablesQuery.sharedWithSensitiveAsync(graphqlClient, {
+            appId: projectId,
+            environment,
+            includeFileContent,
+        })
+        : await EnvironmentVariablesQuery_1.EnvironmentVariablesQuery.sharedAsync(graphqlClient, {
+            appId: projectId,
+            environment,
+            includeFileContent,
+        });
+}
+class EnvList extends EasCommand_1.default {
+    static description = 'list environment variables for the current project or account';
+    static contextDefinition = {
+        ...this.ContextOptions.ProjectId,
+        ...this.ContextOptions.LoggedIn,
+    };
+    static flags = {
+        'include-sensitive': core_1.Flags.boolean({
+            description: 'Display sensitive values in the output',
+            default: false,
+        }),
+        'include-file-content': core_1.Flags.boolean({
+            description: 'Display files content in the output',
+            default: false,
+        }),
+        ...flags_1.EASMultiEnvironmentFlag,
+        ...flags_1.EASVariableFormatFlag,
+        ...flags_1.EASEnvironmentVariableScopeFlag,
+    };
+    static args = {
+        environment: core_1.Args.string({
+            description: "Environment to list the variables from. Default environments are 'production', 'preview', and 'development'.",
+            required: false,
+        }),
+    };
+    async runAsync() {
+        const { args, flags } = await this.parse(EnvList);
+        let { format, environment: environments, scope, 'include-sensitive': includeSensitive, 'include-file-content': includeFileContent, 'non-interactive': nonInteractive, } = this.sanitizeInputs(flags, args);
+        const { projectId, loggedIn: { graphqlClient }, } = await this.getContextAsync(EnvList, {
+            nonInteractive: true,
+        });
+        if (!environments) {
+            environments = await (0, prompts_1.promptVariableEnvironmentAsync)({
+                nonInteractive,
+                multiple: true,
+                graphqlClient,
+                projectId,
+            });
+        }
+        await (0, variableUtils_1.performForEnvironmentsAsync)(environments, async (environment) => {
+            const variables = await getVariablesForScopeAsync(graphqlClient, {
+                scope,
+                includingSensitive: includeSensitive,
+                includeFileContent,
+                environment,
+                projectId,
+            });
+            log_1.default.addNewLineIfNone();
+            if (environment) {
+                log_1.default.log(chalk_1.default.bold(`Environment: ${environment.toLocaleLowerCase()}`));
+            }
+            if (variables.length === 0) {
+                log_1.default.log('No variables found for this environment.');
+                return;
+            }
+            if (format === 'short') {
+                for (const variable of variables) {
+                    log_1.default.log(`${chalk_1.default.bold(variable.name)}=${(0, variableUtils_1.formatVariableValue)(variable)}`);
+                }
+            }
+            else {
+                if (scope === generated_1.EnvironmentVariableScope.Shared) {
+                    log_1.default.log(chalk_1.default.bold('Account-wide variables for this account:'));
+                }
+                else {
+                    log_1.default.log(chalk_1.default.bold(`Variables for this project:`));
+                }
+                log_1.default.log(variables.map(variable => (0, variableUtils_1.formatVariable)(variable)).join(`\n\n${chalk_1.default.dim('———')}\n\n`));
+            }
+        });
+    }
+    sanitizeInputs(flags, { environment }) {
+        const environments = flags.environment ?? (environment ? [environment] : undefined);
+        return {
+            ...flags,
+            'non-interactive': flags['non-interactive'] ?? false,
+            environment: environments,
+            scope: flags.scope === 'account'
+                ? generated_1.EnvironmentVariableScope.Shared
+                : generated_1.EnvironmentVariableScope.Project,
+        };
+    }
+}
+exports.default = EnvList;

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

@@ -0,0 +1,18 @@
+import EasCommand from '../../commandUtils/EasCommand';
+export default class EnvPull extends EasCommand {
+    static description: string;
+    static contextDefinition: {
+        projectDir: import("../../commandUtils/context/ProjectDirContextField").default;
+        loggedIn: import("../../commandUtils/context/LoggedInContextField").default;
+        projectId: import("../../commandUtils/context/ProjectIdContextField").ProjectIdContextField;
+    };
+    static args: {
+        environment: import("@oclif/core/lib/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        path: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        environment: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'non-interactive': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    runAsync(): Promise<void>;
+}

package/build/commands/env/pull.js

@@ -0,0 +1,106 @@
+"use strict";
+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 = tslib_1.__importStar(require("fs-extra"));
+const path_1 = tslib_1.__importDefault(require("path"));
+const EasCommand_1 = tslib_1.__importDefault(require("../../commandUtils/EasCommand"));
+const flags_1 = require("../../commandUtils/flags");
+const generated_1 = require("../../graphql/generated");
+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 EnvPull extends EasCommand_1.default {
+    static description = 'pull environment variables for the selected environment to .env file';
+    static contextDefinition = {
+        ...this.ContextOptions.ProjectId,
+        ...this.ContextOptions.LoggedIn,
+        ...this.ContextOptions.ProjectDir,
+    };
+    static args = {
+        environment: core_1.Args.string({
+            description: "Environment to pull variables from. Default environments are 'production', 'preview', and 'development'.",
+            required: false,
+        }),
+    };
+    static flags = {
+        ...flags_1.EASNonInteractiveFlag,
+        ...flags_1.EASEnvironmentFlag,
+        path: core_1.Flags.string({
+            description: 'Path to the result `.env` file',
+            default: '.env.local',
+        }),
+    };
+    async runAsync() {
+        let { args: { environment: argEnvironment }, flags: { environment: flagEnvironment, path: targetPath, 'non-interactive': nonInteractive }, } = await this.parse(EnvPull);
+        let environment = flagEnvironment?.toLowerCase() ?? argEnvironment?.toLowerCase();
+        const { projectId, loggedIn: { graphqlClient }, projectDir, } = await this.getContextAsync(EnvPull, {
+            nonInteractive,
+        });
+        if (!environment) {
+            environment = await (0, prompts_2.promptVariableEnvironmentAsync)({
+                nonInteractive,
+                graphqlClient,
+                projectId,
+            });
+        }
+        targetPath = targetPath ?? '.env.local';
+        const environmentVariables = await EnvironmentVariablesQuery_1.EnvironmentVariablesQuery.byAppIdWithSensitiveAsync(graphqlClient, {
+            appId: projectId,
+            environment,
+            includeFileContent: true,
+        });
+        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.`);
+            }
+        }
+        let currentEnvLocal = {};
+        if (await fs.exists(targetPath)) {
+            currentEnvLocal = dotenv_1.default.parse(await fs.readFile(targetPath, 'utf8'));
+        }
+        const filePrefix = `# Environment: ${environment.toLocaleLowerCase()}\n\n`;
+        const isFileVariablePresent = environmentVariables.some(v => {
+            return v.type === generated_1.EnvironmentSecretType.FileBase64 && v.valueWithFileContent;
+        });
+        const envDir = path_1.default.join(projectDir, '.eas', '.env');
+        if (isFileVariablePresent) {
+            await fs.mkdir(envDir, { recursive: true });
+        }
+        const skippedSecretVariables = [];
+        const overridenSecretVariables = [];
+        const envFileContentLines = await Promise.all(environmentVariables.map(async (variable) => {
+            if (variable.visibility === generated_1.EnvironmentVariableVisibility.Secret) {
+                if (currentEnvLocal[variable.name]) {
+                    overridenSecretVariables.push(variable.name);
+                    return `${variable.name}=${currentEnvLocal[variable.name]}`;
+                }
+                skippedSecretVariables.push(variable.name);
+                return `# ${variable.name}=***** (secret)`;
+            }
+            if (variable.type === generated_1.EnvironmentSecretType.FileBase64 && variable.valueWithFileContent) {
+                const filePath = path_1.default.join(envDir, variable.name);
+                await fs.writeFile(filePath, variable.valueWithFileContent, 'base64');
+                return `${variable.name}=${filePath}`;
+            }
+            return `${variable.name}=${variable.value}`;
+        }));
+        await fs.writeFile(targetPath, filePrefix + envFileContentLines.join('\n'));
+        log_1.default.log(`Pulled plain text and sensitive environment variables from "${environment.toLowerCase()}" environment to ${targetPath}.`);
+        if (overridenSecretVariables.length > 0) {
+            log_1.default.addNewLineIfNone();
+            log_1.default.log(`Reused local values for following secrets: ${overridenSecretVariables.join('\n')}.`);
+        }
+        if (skippedSecretVariables.length > 0) {
+            log_1.default.addNewLineIfNone();
+            log_1.default.log(`The following variables have the secret visibility and can't be read outside of EAS servers. Set their values manually in your .env file: ${skippedSecretVariables.join(', ')}.`);
+        }
+    }
+}
+exports.default = EnvPull;

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

@@ -0,0 +1,29 @@
+import EasCommand from '../../commandUtils/EasCommand';
+export default class EnvPush extends EasCommand {
+    static description: string;
+    static contextDefinition: {
+        loggedIn: import("../../commandUtils/context/LoggedInContextField").default;
+        projectId: import("../../commandUtils/context/ProjectIdContextField").ProjectIdContextField;
+    };
+    static flags: {
+        path: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        force: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        environment: import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+    };
+    static args: {
+        environment: import("@oclif/core/lib/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    runAsync(): Promise<void>;
+    parseFlagsAndArgs(flags: {
+        path: string;
+        environment: string[] | undefined;
+        force: boolean;
+    }, { environment }: {
+        environment?: string;
+    }): {
+        environment?: string[];
+        path: string;
+        force: boolean;
+    };
+    private parseEnvFileAsync;
+}