@donotuse/eas-cli 18.5.0-rc.1

package/build/commands/env/push.js

@@ -0,0 +1,193 @@
+"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_extra_1 = tslib_1.__importDefault(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 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 EnvPush extends EasCommand_1.default {
+    static description = 'push environment variables from .env file to the selected environment';
+    static contextDefinition = {
+        ...this.ContextOptions.ProjectId,
+        ...this.ContextOptions.LoggedIn,
+    };
+    static flags = {
+        ...flags_1.EASMultiEnvironmentFlag,
+        path: core_1.Flags.string({
+            description: 'Path to the input `.env` file',
+            default: '.env.local',
+        }),
+        force: core_1.Flags.boolean({
+            description: 'Skip confirmation and automatically override existing variables',
+            default: false,
+        }),
+    };
+    static args = {
+        environment: core_1.Args.string({
+            description: "Environment to push variables to. Default environments are 'production', 'preview', and 'development'.",
+            required: false,
+        }),
+    };
+    async runAsync() {
+        const { args, flags } = await this.parse(EnvPush);
+        let { environment: environments, path: envPath, force } = this.parseFlagsAndArgs(flags, args);
+        const { projectId, loggedIn: { graphqlClient }, } = await this.getContextAsync(EnvPush, {
+            nonInteractive: false,
+        });
+        if (!environments) {
+            environments = await (0, prompts_2.promptVariableEnvironmentAsync)({
+                nonInteractive: false,
+                multiple: true,
+                canEnterCustomEnvironment: true,
+                graphqlClient,
+                projectId,
+            });
+        }
+        const updateVariables = await this.parseEnvFileAsync(envPath, environments);
+        const variableNames = Object.keys(updateVariables);
+        for (const environment of environments) {
+            const displayedEnvironment = environment.toLocaleLowerCase();
+            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(existingVariable => {
+                const existingVariableUpdate = updateVariables[existingVariable.name];
+                if (existingVariableUpdate) {
+                    const hasMoreEnvironments = existingVariableUpdate.environments.some(newEnv => !existingVariable.environments?.includes(newEnv));
+                    if (existingVariableUpdate.value !== existingVariable.value || hasMoreEnvironments) {
+                        existingDifferentVariables.push(existingVariable);
+                    }
+                    else {
+                        delete updateVariables[existingVariable.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('Account-wide 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('Account-wide variables cannot be overwritten by eas env:push command');
+            }
+            if (existingDifferentVariables.length > 0) {
+                log_1.default.warn(`Some variables already exist in the ${displayedEnvironment} environment.`);
+                const variableNames = existingDifferentVariables.map(variable => variable.name);
+                let variablesToOverwrite = [];
+                if (force) {
+                    // When --force is used, automatically override all existing variables
+                    log_1.default.log('Using --force flag: automatically overriding existing variables.');
+                    variablesToOverwrite = existingDifferentVariables.map(variable => variable.name);
+                }
+                else {
+                    const confirmationMessage = variableNames.length > 1
+                        ? `The ${variableNames.join(', ')} environment variables already exist in ${displayedEnvironment} environment. Do you want to override them all?`
+                        : `The ${variableNames[0]} environment variable already exists in ${displayedEnvironment} environment. Do you want to override it?`;
+                    const confirm = await (0, prompts_1.confirmAsync)({
+                        message: confirmationMessage,
+                    });
+                    if (!confirm && existingDifferentVariables.length === 0) {
+                        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.visibility !== generated_1.EnvironmentVariableVisibility.Public);
+            if (existingSensitiveVariables.length > 0 && !force) {
+                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...');
+                }
+            }
+            else if (existingSensitiveVariables.length > 0 && force) {
+                log_1.default.log('Using --force flag: automatically overriding sensitive variables.');
+            }
+        }
+        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 ${environments.join(', ').toLocaleLowerCase()}.`);
+    }
+    parseFlagsAndArgs(flags, { environment }) {
+        const environments = flags.environment ?? (environment ? [environment] : undefined);
+        return {
+            ...flags,
+            environment: environments,
+        };
+    }
+    async parseEnvFileAsync(envPath, environments) {
+        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'));
+        const hasFileVariables = Object.values(variables).some(value => value.includes(path_1.default.join('.eas', '.env')));
+        if (hasFileVariables) {
+            log_1.default.warn('File variables are not supported in this command.');
+        }
+        for (const [name, value] of Object.entries(variables)) {
+            // Skip file variables
+            const fileVariablePath = path_1.default.join('.eas', '.env', name);
+            if (value.endsWith(fileVariablePath)) {
+                log_1.default.warn(`Skipping file variable ${name}`);
+                continue;
+            }
+            pushInput[name] = {
+                name,
+                value,
+                environments,
+                visibility: name.startsWith('EXPO_PUBLIC_')
+                    ? generated_1.EnvironmentVariableVisibility.Public
+                    : generated_1.EnvironmentVariableVisibility.Sensitive,
+            };
+        }
+        return pushInput;
+    }
+}
+exports.default = EnvPush;

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

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

package/build/commands/env/unlink.js

@@ -0,0 +1,117 @@
+"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 EnvUnlink extends EasCommand_1.default {
+    static description = 'unlink an account-wide environment variable from 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',
+        }),
+        ...flags_1.EASMultiEnvironmentFlag,
+        ...flags_1.EASNonInteractiveFlag,
+    };
+    static contextDefinition = {
+        ...this.ContextOptions.ProjectId,
+        ...this.ContextOptions.LoggedIn,
+    };
+    static args = [
+        {
+            name: 'environment',
+            description: "Environment to unlink the variable from. One of 'production', 'preview', or 'development'.",
+            required: false,
+        },
+    ];
+    async runAsync() {
+        const { args, flags } = await this.parse(EnvUnlink);
+        let { 'variable-name': name, 'non-interactive': nonInteractive, environment: unlinkEnvironments, } = this.validateInputs(flags, args);
+        const { projectId, loggedIn: { graphqlClient }, } = await this.getContextAsync(EnvUnlink, {
+            nonInteractive,
+        });
+        const projectDisplayName = await (0, projectUtils_1.getDisplayNameForProjectIdAsync)(graphqlClient, projectId);
+        const variables = await EnvironmentVariablesQuery_1.EnvironmentVariablesQuery.sharedAsync(graphqlClient, {
+            appId: projectId,
+            filterNames: name ? [name] : undefined,
+        });
+        let selectedVariable = variables[0];
+        if (variables.length > 1) {
+            if (nonInteractive) {
+                throw new Error("Multiple variables found, please select one using '--variable-name'");
+            }
+            selectedVariable = await (0, prompts_1.selectAsync)('Select 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 && !unlinkEnvironments) {
+            const selectedEnvironments = (selectedVariable.linkedEnvironments ?? []).length > 0
+                ? selectedVariable.linkedEnvironments
+                : selectedVariable.environments;
+            const environments = await (0, prompts_2.promptVariableEnvironmentAsync)({
+                nonInteractive,
+                multiple: true,
+                selectedEnvironments: selectedEnvironments ?? [],
+            });
+            explicitSelect = true;
+            unlinkEnvironments = Object.values(generated_1.EnvironmentVariableEnvironment).filter(env => !environments.includes(env));
+        }
+        if (!unlinkEnvironments) {
+            await EnvironmentVariableMutation_1.EnvironmentVariableMutation.unlinkSharedEnvironmentVariableAsync(graphqlClient, selectedVariable.id, projectId);
+            log_1.default.withTick(`Unlinked variable ${chalk_1.default.bold(selectedVariable.name)} from project ${chalk_1.default.bold(projectDisplayName)} in ${selectedVariable.environments?.join(', ').toLocaleLowerCase()}.`);
+            return;
+        }
+        for (const environment of Object.values(generated_1.EnvironmentVariableEnvironment)) {
+            if (selectedVariable.linkedEnvironments?.includes(environment) !==
+                unlinkEnvironments.includes(environment)) {
+                if (!explicitSelect && unlinkEnvironments.includes(environment)) {
+                    log_1.default.withTick(`Variable ${chalk_1.default.bold(selectedVariable.name)} is already unlinked from ${environment.toLocaleLowerCase()}.`);
+                }
+                continue;
+            }
+            if (unlinkEnvironments.includes(environment)) {
+                await EnvironmentVariableMutation_1.EnvironmentVariableMutation.unlinkSharedEnvironmentVariableAsync(graphqlClient, selectedVariable.id, projectId, environment);
+                log_1.default.withTick(`Unlinked variable ${chalk_1.default.bold(selectedVariable.name)} from project ${chalk_1.default.bold(projectDisplayName)} in ${environment.toLocaleLowerCase()}.`);
+            }
+            else if (explicitSelect) {
+                await EnvironmentVariableMutation_1.EnvironmentVariableMutation.linkSharedEnvironmentVariableAsync(graphqlClient, selectedVariable.id, projectId, environment);
+                log_1.default.withTick(`Linked variable ${chalk_1.default.bold(selectedVariable.name)} to project ${chalk_1.default.bold(projectDisplayName)} in ${environment.toLocaleLowerCase()}.`);
+            }
+        }
+    }
+    validateInputs(flags, { environment }) {
+        if (flags['non-interactive']) {
+            if (!flags['variable-name']) {
+                throw new Error('Current name is required in non-interactive mode. Run the command with --variable-name flag.');
+            }
+        }
+        if (environment) {
+            environment = environment.toUpperCase();
+            if (!(0, variableUtils_1.isEnvironment)(environment)) {
+                throw new Error("Invalid environment. Use one of 'production', 'preview', or 'development'.");
+            }
+            return {
+                environment: [environment],
+                ...flags,
+            };
+        }
+        return flags;
+    }
+}
+exports.default = EnvUnlink;

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

@@ -0,0 +1,26 @@
+import EasCommand from '../../commandUtils/EasCommand';
+export default class EnvUpdate extends EasCommand {
+    static description: string;
+    static flags: {
+        'non-interactive': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        environment: import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        scope: import("@oclif/core/lib/interfaces").OptionFlag<"project" | "account", import("@oclif/core/lib/interfaces").CustomOptions>;
+        visibility: import("@oclif/core/lib/interfaces").OptionFlag<"plaintext" | "sensitive" | "secret" | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'variable-name': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'variable-environment': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        name: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        value: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        type: import("@oclif/core/lib/interfaces").OptionFlag<"string" | "file" | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+    };
+    static args: {
+        environment: import("@oclif/core/lib/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static contextDefinition: {
+        loggedIn: import("../../commandUtils/context/LoggedInContextField").default;
+        analytics: import("../../commandUtils/context/AnalyticsContextField").default;
+        projectId: import("../../commandUtils/context/ProjectIdContextField").ProjectIdContextField;
+    };
+    runAsync(): Promise<void>;
+    private sanitizeInputs;
+    private promptForMissingFlagsAsync;
+}

package/build/commands/env/update.js

@@ -0,0 +1,229 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const core_1 = require("@oclif/core");
+const assert_1 = tslib_1.__importDefault(require("assert"));
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const fs_extra_1 = tslib_1.__importDefault(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 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 EnvUpdate extends EasCommand_1.default {
+    static description = 'update an environment variable on the current project or account';
+    static flags = {
+        'variable-name': core_1.Flags.string({
+            description: 'Current name of the variable',
+        }),
+        'variable-environment': core_1.Flags.string({
+            ...flags_1.EasEnvironmentFlagParameters,
+            description: 'Current environment of the variable to update',
+        }),
+        name: core_1.Flags.string({
+            description: 'New name of the variable',
+        }),
+        value: core_1.Flags.string({
+            description: 'New value or the variable',
+        }),
+        type: core_1.Flags.option({
+            description: 'The type of variable',
+            options: ['string', 'file'],
+        })(),
+        ...flags_1.EASVariableVisibilityFlag,
+        ...flags_1.EASEnvironmentVariableScopeFlag,
+        ...flags_1.EASMultiEnvironmentFlag,
+        ...flags_1.EASNonInteractiveFlag,
+    };
+    static args = {
+        environment: core_1.Args.string({
+            description: "Current environment of the variable to update. Default environments are 'production', 'preview', and 'development'.",
+            required: false,
+        }),
+    };
+    static contextDefinition = {
+        ...this.ContextOptions.ProjectId,
+        ...this.ContextOptions.Analytics,
+        ...this.ContextOptions.LoggedIn,
+    };
+    async runAsync() {
+        const { args, flags } = await this.parse(EnvUpdate);
+        const { name, value: rawValue, scope, 'variable-name': currentName, 'variable-environment': currentEnvironment, 'non-interactive': nonInteractive, environment: environments, type, visibility, } = this.sanitizeInputs(flags, args);
+        const { projectId, loggedIn: { graphqlClient }, } = await this.getContextAsync(EnvUpdate, {
+            nonInteractive,
+        });
+        const [projectDisplayName, ownerAccount] = await Promise.all([
+            (0, projectUtils_1.getDisplayNameForProjectIdAsync)(graphqlClient, projectId),
+            (0, projectUtils_1.getOwnerAccountForProjectIdAsync)(graphqlClient, projectId),
+        ]);
+        let selectedVariable;
+        let existingVariables = [];
+        const suffix = scope === generated_1.EnvironmentVariableScope.Project
+            ? `on project ${projectDisplayName}`
+            : `on account ${ownerAccount.name}`;
+        if (scope === generated_1.EnvironmentVariableScope.Project) {
+            existingVariables = await EnvironmentVariablesQuery_1.EnvironmentVariablesQuery.byAppIdAsync(graphqlClient, {
+                appId: projectId,
+                environment: currentEnvironment,
+                filterNames: currentName ? [currentName] : undefined,
+            });
+        }
+        if (scope === generated_1.EnvironmentVariableScope.Shared) {
+            existingVariables = await EnvironmentVariablesQuery_1.EnvironmentVariablesQuery.sharedAsync(graphqlClient, {
+                appId: projectId,
+                environment: currentEnvironment,
+                filterNames: currentName ? [currentName] : undefined,
+            });
+        }
+        if (existingVariables.length === 0) {
+            throw new Error(`Variable with name ${currentName} ${currentEnvironment ? `in environment ${currentEnvironment.toLocaleLowerCase()}` : ''} does not exist ${suffix}.`);
+        }
+        else if (existingVariables.length > 1) {
+            selectedVariable = await (0, prompts_1.selectAsync)('Select variable', existingVariables.map(variable => ({
+                title: (0, variableUtils_1.formatVariableName)(variable),
+                value: variable,
+            })));
+        }
+        else {
+            selectedVariable = existingVariables[0];
+        }
+        (0, assert_1.default)(selectedVariable, 'Variable must be selected');
+        const { name: newName, value: newValue, environment: newEnvironments, visibility: newVisibility, type: newType, fileName, } = await this.promptForMissingFlagsAsync(selectedVariable, {
+            name,
+            value: rawValue,
+            environment: environments,
+            visibility,
+            'non-interactive': nonInteractive,
+            type,
+            scope,
+        }, { graphqlClient, projectId });
+        const variable = await EnvironmentVariableMutation_1.EnvironmentVariableMutation.updateAsync(graphqlClient, {
+            id: selectedVariable.id,
+            name: newName,
+            value: newValue,
+            environments: newEnvironments,
+            type: newType,
+            visibility: newVisibility,
+            fileName: newValue ? fileName : undefined,
+        });
+        if (!variable) {
+            throw new Error(`Could not update variable with name ${name} ${suffix}`);
+        }
+        log_1.default.withTick(`Updated variable ${chalk_1.default.bold(selectedVariable.name)} ${suffix}.`);
+    }
+    sanitizeInputs(flags, { environment }) {
+        if (flags['non-interactive']) {
+            if (!flags['variable-name']) {
+                throw new Error('Current name is required in non-interactive mode. Run the command with --variable-name flag.');
+            }
+            if (flags['type'] && !flags['value']) {
+                throw new Error('Value is required when type is set. Run the command with --value flag.');
+            }
+        }
+        const scope = flags.scope === 'account'
+            ? generated_1.EnvironmentVariableScope.Shared
+            : generated_1.EnvironmentVariableScope.Project;
+        if (environment) {
+            return {
+                ...flags,
+                'variable-environment': environment,
+                scope,
+            };
+        }
+        return { ...flags, scope };
+    }
+    async promptForMissingFlagsAsync(selectedVariable, { name, value, environment: environments, visibility, 'non-interactive': nonInteractive, type, ...rest }, { graphqlClient, projectId }) {
+        let newType;
+        let newVisibility;
+        let fileName;
+        if (type === 'file') {
+            newType = generated_1.EnvironmentSecretType.FileBase64;
+        }
+        else if (type === 'string') {
+            newType = generated_1.EnvironmentSecretType.String;
+        }
+        if (!nonInteractive) {
+            if (!name) {
+                name = await (0, prompts_2.promptVariableNameAsync)(nonInteractive, selectedVariable.name);
+                if (!name || name.length === 0) {
+                    name = undefined;
+                }
+            }
+            if (!type && !value && !nonInteractive) {
+                newType = await (0, prompts_2.promptVariableTypeAsync)(nonInteractive, selectedVariable.type);
+            }
+            if (!value) {
+                value = await (0, prompts_2.promptVariableValueAsync)({
+                    nonInteractive,
+                    required: false,
+                    filePath: (newType ?? selectedVariable.type) === generated_1.EnvironmentSecretType.FileBase64,
+                    initial: (newType ?? selectedVariable.type) === generated_1.EnvironmentSecretType.FileBase64
+                        ? undefined
+                        : selectedVariable.value,
+                });
+                if (!value || value.length === 0 || value === selectedVariable.value) {
+                    value = undefined;
+                    newType = undefined;
+                }
+            }
+            if (!environments || environments.length === 0) {
+                environments = await (0, prompts_2.promptVariableEnvironmentAsync)({
+                    nonInteractive,
+                    multiple: true,
+                    canEnterCustomEnvironment: true,
+                    selectedEnvironments: selectedVariable.environments ?? [],
+                    graphqlClient,
+                    projectId,
+                });
+                if (!environments ||
+                    environments.length === 0 ||
+                    environments === selectedVariable.environments) {
+                    environments = undefined;
+                }
+            }
+            if (!visibility) {
+                newVisibility = await (0, prompts_2.promptVariableVisibilityAsync)(nonInteractive, selectedVariable.visibility);
+                if (!newVisibility || newVisibility === selectedVariable.visibility) {
+                    newVisibility = undefined;
+                }
+            }
+        }
+        // If value is provided but type is not explicitly set, preserve the existing type
+        if (value && !newType) {
+            newType = selectedVariable.type;
+        }
+        if (newType === generated_1.EnvironmentSecretType.FileBase64 && value) {
+            const environmentFilePath = path_1.default.resolve(value);
+            if (!(await fs_extra_1.default.pathExists(environmentFilePath))) {
+                if (type === 'file') {
+                    throw new Error(`File "${value}" does not exist`);
+                }
+                else {
+                    throw new Error(`Variable "${selectedVariable.name}" is a file type, but "${value}" does not exist as a file. If you want to convert it to a string, pass --type string.`);
+                }
+            }
+            fileName = path_1.default.basename(environmentFilePath);
+            value = await fs_extra_1.default.readFile(environmentFilePath, 'base64');
+        }
+        if (visibility) {
+            newVisibility = (0, prompts_2.parseVisibility)(visibility);
+        }
+        return {
+            ...rest,
+            name,
+            value,
+            environment: environments,
+            visibility: newVisibility,
+            'non-interactive': nonInteractive,
+            type: newType,
+            fileName,
+        };
+    }
+}
+exports.default = EnvUpdate;

package/build/commands/fingerprint/compare.d.ts

@@ -0,0 +1,26 @@
+import EasCommand from '../../commandUtils/EasCommand';
+export default class FingerprintCompare extends EasCommand {
+    static description: string;
+    static strict: boolean;
+    static examples: string[];
+    static args: {
+        hash1: import("@oclif/core/lib/interfaces").Arg<string | undefined, Record<string, unknown>>;
+        hash2: import("@oclif/core/lib/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        'non-interactive': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        'build-id': import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'update-id': import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        open: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        environment: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+    };
+    static contextDefinition: {
+        getServerSideEnvironmentVariablesAsync: import("../../commandUtils/context/ServerSideEnvironmentVariablesContextField").ServerSideEnvironmentVariablesContextField;
+        vcsClient: import("../../commandUtils/context/VcsClientContextField").default;
+        loggedIn: import("../../commandUtils/context/LoggedInContextField").default;
+        privateProjectConfig: import("../../commandUtils/context/PrivateProjectConfigContextField").PrivateProjectConfigContextField;
+        projectId: import("../../commandUtils/context/ProjectIdContextField").ProjectIdContextField;
+    };
+    runAsync(): Promise<void>;
+}