@donotuse/eas-cli 18.5.0-rc.1

package/build/commands/env/create.js

@@ -0,0 +1,226 @@
+"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 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");
+class EnvCreate extends EasCommand_1.default {
+    static description = 'create an environment variable for the current project or account';
+    static args = {
+        environment: core_1.Args.string({
+            description: "Environment to create the variable in. Default environments are 'production', 'preview', and 'development'.",
+            required: false,
+        }),
+    };
+    static flags = {
+        name: core_1.Flags.string({
+            description: 'Name of the variable',
+        }),
+        value: core_1.Flags.string({
+            description: 'Text value or the variable',
+        }),
+        force: core_1.Flags.boolean({
+            description: 'Overwrite existing variable',
+            default: false,
+        }),
+        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 contextDefinition = {
+        ...this.ContextOptions.ProjectId,
+        ...this.ContextOptions.Analytics,
+        ...this.ContextOptions.LoggedIn,
+    };
+    async runAsync() {
+        const { args, flags } = await this.parse(EnvCreate);
+        const validatedFlags = this.sanitizeFlags(flags);
+        const { projectId, loggedIn: { graphqlClient }, } = await this.getContextAsync(EnvCreate, {
+            nonInteractive: validatedFlags['non-interactive'],
+        });
+        const { name, value, scope, 'non-interactive': nonInteractive, environment: environments, visibility, force, type, fileName, } = await this.promptForMissingFlagsAsync(validatedFlags, args, {
+            graphqlClient,
+            projectId,
+        });
+        const [projectDisplayName, ownerAccount] = await Promise.all([
+            (0, projectUtils_1.getDisplayNameForProjectIdAsync)(graphqlClient, projectId),
+            (0, projectUtils_1.getOwnerAccountForProjectIdAsync)(graphqlClient, projectId),
+        ]);
+        let overwrite = false;
+        if (scope === generated_1.EnvironmentVariableScope.Project) {
+            const existingVariables = await EnvironmentVariablesQuery_1.EnvironmentVariablesQuery.byAppIdAsync(graphqlClient, {
+                appId: projectId,
+                filterNames: [name],
+            });
+            const existingVariable = existingVariables.find(variable => !environments || variable.environments?.some(env => environments?.includes(env)));
+            if (existingVariable) {
+                if (existingVariable.scope === generated_1.EnvironmentVariableScope.Project) {
+                    await this.promptForOverwriteAsync({
+                        nonInteractive,
+                        force,
+                        message: `Variable ${name} already exists on this project.`,
+                        suggestion: 'Do you want to overwrite it?',
+                    });
+                    overwrite = true;
+                }
+            }
+            const variable = overwrite && existingVariable
+                ? await EnvironmentVariableMutation_1.EnvironmentVariableMutation.updateAsync(graphqlClient, {
+                    id: existingVariable.id,
+                    name,
+                    value,
+                    visibility,
+                    environments,
+                    type,
+                    fileName,
+                })
+                : await EnvironmentVariableMutation_1.EnvironmentVariableMutation.createForAppAsync(graphqlClient, {
+                    name,
+                    value,
+                    environments,
+                    visibility,
+                    type: type ?? generated_1.EnvironmentSecretType.String,
+                    fileName,
+                }, projectId);
+            if (!variable) {
+                throw new Error(`Could not create variable with name ${name} on project ${projectDisplayName}`);
+            }
+            log_1.default.withTick(`Created a new variable ${chalk_1.default.bold(name)} on project ${chalk_1.default.bold(projectDisplayName)}.`);
+        }
+        else if (scope === generated_1.EnvironmentVariableScope.Shared) {
+            const existingVariables = await EnvironmentVariablesQuery_1.EnvironmentVariablesQuery.sharedAsync(graphqlClient, {
+                appId: projectId,
+                filterNames: [name],
+            });
+            const existingVariable = existingVariables.find(variable => !environments || variable.environments?.some(env => environments?.includes(env)));
+            if (existingVariable) {
+                if (force) {
+                    overwrite = true;
+                }
+                else {
+                    throw new Error(`Account-wide variable with ${name} name already exists on this account.\n` +
+                        `Use a different name or delete the existing variable on website or by using the "eas env:delete --name ${name} --scope account" command.`);
+                }
+            }
+            const variable = overwrite && existingVariable
+                ? await EnvironmentVariableMutation_1.EnvironmentVariableMutation.updateAsync(graphqlClient, {
+                    id: existingVariable.id,
+                    name,
+                    value,
+                    visibility,
+                    environments,
+                    type,
+                })
+                : await EnvironmentVariableMutation_1.EnvironmentVariableMutation.createSharedVariableAsync(graphqlClient, {
+                    name,
+                    value,
+                    visibility,
+                    environments,
+                    type: type ?? generated_1.EnvironmentSecretType.String,
+                }, ownerAccount.id);
+            if (!variable) {
+                throw new Error(`Could not create variable with name ${name} on account ${ownerAccount.name}`);
+            }
+            log_1.default.withTick(`Created a new variable ${chalk_1.default.bold(name)} on account ${chalk_1.default.bold(ownerAccount.name)}.`);
+        }
+    }
+    async promptForOverwriteAsync({ nonInteractive, force, message, suggestion, }) {
+        if (!nonInteractive) {
+            const confirmation = await (0, prompts_1.confirmAsync)({
+                message: `${message} ${suggestion}`,
+            });
+            if (!confirmation) {
+                log_1.default.log('Aborting');
+                throw new Error(`${message}`);
+            }
+        }
+        else if (!force) {
+            throw new Error(`${message} Use --force to overwrite it.`);
+        }
+    }
+    async promptForMissingFlagsAsync({ name, value, environment: environments, visibility, 'non-interactive': nonInteractive, type, ...rest }, { environment }, { graphqlClient, projectId }) {
+        if (!name) {
+            name = await (0, prompts_2.promptVariableNameAsync)(nonInteractive);
+        }
+        let newType;
+        let newVisibility = visibility ? (0, prompts_2.parseVisibility)(visibility) : undefined;
+        if (type === 'file') {
+            newType = generated_1.EnvironmentSecretType.FileBase64;
+        }
+        else if (type === 'string') {
+            newType = generated_1.EnvironmentSecretType.String;
+        }
+        if (!type && !value && !nonInteractive) {
+            newType = await (0, prompts_2.promptVariableTypeAsync)(nonInteractive);
+        }
+        if (!newVisibility) {
+            newVisibility = await (0, prompts_2.promptVariableVisibilityAsync)(nonInteractive);
+        }
+        if (!value) {
+            value = await (0, prompts_2.promptVariableValueAsync)({
+                nonInteractive,
+                hidden: newVisibility !== generated_1.EnvironmentVariableVisibility.Public,
+                filePath: newType === generated_1.EnvironmentSecretType.FileBase64,
+            });
+        }
+        let environmentFilePath;
+        let fileName;
+        if (newType === generated_1.EnvironmentSecretType.FileBase64) {
+            environmentFilePath = path_1.default.resolve(value);
+            if (!(await fs_extra_1.default.pathExists(environmentFilePath))) {
+                throw new Error(`File "${value}" does not exist`);
+            }
+            fileName = path_1.default.basename(environmentFilePath);
+        }
+        value = environmentFilePath ? await fs_extra_1.default.readFile(environmentFilePath, 'base64') : value;
+        let newEnvironments = environments ?? (environment ? [environment] : undefined);
+        if (!newEnvironments) {
+            newEnvironments = await (0, prompts_2.promptVariableEnvironmentAsync)({
+                nonInteractive,
+                multiple: true,
+                canEnterCustomEnvironment: true,
+                graphqlClient,
+                projectId,
+            });
+            if (!newEnvironments || newEnvironments.length === 0) {
+                throw new Error('No environments selected');
+            }
+        }
+        newVisibility = newVisibility ?? generated_1.EnvironmentVariableVisibility.Public;
+        return {
+            name,
+            value,
+            environment: newEnvironments,
+            visibility: newVisibility,
+            force: rest.force ?? false,
+            'non-interactive': nonInteractive,
+            type: newType,
+            fileName,
+            ...rest,
+        };
+    }
+    sanitizeFlags(flags) {
+        return {
+            ...flags,
+            scope: flags.scope === 'account'
+                ? generated_1.EnvironmentVariableScope.Shared
+                : generated_1.EnvironmentVariableScope.Project,
+        };
+    }
+}
+exports.default = EnvCreate;

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

@@ -0,0 +1,19 @@
+import EasCommand from '../../commandUtils/EasCommand';
+export default class EnvDelete extends EasCommand {
+    static description: string;
+    static flags: {
+        'non-interactive': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        scope: import("@oclif/core/lib/interfaces").OptionFlag<"project" | "account", 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>;
+    };
+    static args: {
+        environment: import("@oclif/core/lib/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static contextDefinition: {
+        loggedIn: import("../../commandUtils/context/LoggedInContextField").default;
+        projectId: import("../../commandUtils/context/ProjectIdContextField").ProjectIdContextField;
+    };
+    runAsync(): Promise<void>;
+    private sanitizeInputs;
+}

package/build/commands/env/delete.js

@@ -0,0 +1,115 @@
+"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 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 variableUtils_1 = require("../../utils/variableUtils");
+class EnvDelete extends EasCommand_1.default {
+    static description = 'delete an environment variable for the current project or account';
+    static flags = {
+        'variable-name': core_1.Flags.string({
+            description: 'Name of the variable to delete',
+        }),
+        'variable-environment': core_1.Flags.string({
+            ...flags_1.EasEnvironmentFlagParameters,
+            description: 'Current environment of the variable to delete',
+        }),
+        ...flags_1.EASEnvironmentVariableScopeFlag,
+        ...flags_1.EASNonInteractiveFlag,
+    };
+    static args = {
+        environment: core_1.Args.string({
+            description: "Current environment of the variable to delete. Default environments are 'production', 'preview', and 'development'.",
+            required: false,
+        }),
+    };
+    static contextDefinition = {
+        ...this.ContextOptions.ProjectId,
+        ...this.ContextOptions.LoggedIn,
+    };
+    async runAsync() {
+        const { args, flags } = await this.parse(EnvDelete);
+        const { 'variable-name': name, 'variable-environment': environment, 'non-interactive': nonInteractive, scope, } = this.sanitizeInputs(flags, args);
+        const { projectId, loggedIn: { graphqlClient }, } = await this.getContextAsync(EnvDelete, {
+            nonInteractive,
+        });
+        const variables = scope === generated_1.EnvironmentVariableScope.Project
+            ? await EnvironmentVariablesQuery_1.EnvironmentVariablesQuery.byAppIdAsync(graphqlClient, {
+                appId: projectId,
+                environment,
+            })
+            : await EnvironmentVariablesQuery_1.EnvironmentVariablesQuery.sharedAsync(graphqlClient, {
+                appId: projectId,
+                environment,
+            });
+        let selectedVariable;
+        if (!name) {
+            ({ variable: selectedVariable } = await (0, prompts_1.promptAsync)({
+                type: 'select',
+                name: 'variable',
+                message: 'Pick the variable to be deleted:',
+                choices: variables
+                    .filter(({ scope: variableScope }) => scope === variableScope)
+                    .map(variable => {
+                    return {
+                        title: (0, variableUtils_1.formatVariableName)(variable),
+                        value: variable,
+                    };
+                }),
+            }));
+        }
+        else {
+            const selectedVariables = variables.filter(variable => variable.name === name && (!environment || variable.environments?.includes(environment)));
+            if (selectedVariables.length !== 1) {
+                if (selectedVariables.length === 0) {
+                    throw new Error(`Variable "${name}" not found.`);
+                }
+                else {
+                    throw new Error(`Multiple variables with name "${name}" found. Please select the variable to delete interactively or run command with --variable-environment ENVIRONMENT option.`);
+                }
+            }
+            selectedVariable = selectedVariables[0];
+        }
+        (0, assert_1.default)(selectedVariable, `Variable "${name}" not found.`);
+        if (!nonInteractive) {
+            log_1.default.addNewLineIfNone();
+            log_1.default.warn(`You are about to permanently delete variable ${selectedVariable.name}.`);
+            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 "${selectedVariable.name}" not deleted.`);
+            }
+        }
+        await EnvironmentVariableMutation_1.EnvironmentVariableMutation.deleteAsync(graphqlClient, selectedVariable.id);
+        log_1.default.withTick(`️Deleted variable ${selectedVariable.name}".`);
+    }
+    sanitizeInputs(flags, { environment }) {
+        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`);
+            }
+        }
+        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 = EnvDelete;

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

@@ -0,0 +1,22 @@
+import EasCommand from '../../commandUtils/EasCommand';
+export default class EnvExec extends EasCommand {
+    static description: string;
+    static contextDefinition: {
+        loggedIn: import("../../commandUtils/context/LoggedInContextField").default;
+        projectId: import("../../commandUtils/context/ProjectIdContextField").ProjectIdContextField;
+    };
+    static flags: {
+        'non-interactive': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    static args: {
+        environment: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+        bash_command: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    private isNonInteractive;
+    runAsync(): Promise<void>;
+    private sanitizeFlagsAndArgs;
+    protected catch(err: Error): Promise<any>;
+    private runCommandNonInteractiveWithEnvVarsAsync;
+    private runCommandWithEnvVarsAsync;
+    private loadEnvironmentVariablesAsync;
+}

package/build/commands/env/exec.js

@@ -0,0 +1,158 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const core_1 = require("@oclif/core");
+const spawn_async_1 = tslib_1.__importDefault(require("@expo/spawn-async"));
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const EasCommand_1 = tslib_1.__importDefault(require("../../commandUtils/EasCommand"));
+const flags_1 = require("../../commandUtils/flags");
+const EnvironmentVariablesQuery_1 = require("../../graphql/queries/EnvironmentVariablesQuery");
+const log_1 = tslib_1.__importDefault(require("../../log"));
+const prompts_1 = require("../../utils/prompts");
+class EnvExec extends EasCommand_1.default {
+    static description = 'execute a command with environment variables from the selected environment';
+    static contextDefinition = {
+        ...this.ContextOptions.ProjectId,
+        ...this.ContextOptions.LoggedIn,
+    };
+    static flags = {
+        ...flags_1.EASNonInteractiveFlag,
+    };
+    static args = {
+        environment: core_1.Args.string({
+            required: true,
+            description: "Environment to execute the command in. Default environments are 'production', 'preview', and 'development'.",
+        }),
+        bash_command: core_1.Args.string({
+            required: true,
+            description: 'bash command to execute with the environment variables from the environment',
+        }),
+    };
+    isNonInteractive = false;
+    async runAsync() {
+        const { flags, args } = await this.parse(EnvExec);
+        const parsedFlags = this.sanitizeFlagsAndArgs(flags, args);
+        const { projectId, loggedIn: { graphqlClient }, } = await this.getContextAsync(EnvExec, {
+            nonInteractive: parsedFlags.nonInteractive,
+        });
+        this.isNonInteractive = parsedFlags.nonInteractive;
+        const environment = parsedFlags.environment ??
+            (await (0, prompts_1.promptVariableEnvironmentAsync)({
+                nonInteractive: parsedFlags.nonInteractive,
+                graphqlClient,
+                projectId,
+            }));
+        const environmentVariables = await this.loadEnvironmentVariablesAsync({
+            graphqlClient,
+            projectId,
+            environment,
+            nonInteractive: parsedFlags.nonInteractive,
+        });
+        if (parsedFlags.nonInteractive) {
+            await this.runCommandNonInteractiveWithEnvVarsAsync({
+                command: parsedFlags.command,
+                environmentVariables,
+            });
+        }
+        else {
+            await this.runCommandWithEnvVarsAsync({
+                command: parsedFlags.command,
+                environmentVariables,
+            });
+        }
+    }
+    sanitizeFlagsAndArgs(rawFlags, { bash_command, environment }) {
+        if (rawFlags['non-interactive'] && (!bash_command || !environment)) {
+            throw new Error("You must specify both environment and bash command when running in non-interactive mode. Run command as `eas env:exec ENVIRONMENT 'bash command'`.");
+        }
+        const firstChar = bash_command[0];
+        const lastChar = bash_command[bash_command.length - 1];
+        const cleanCommand = (firstChar === '"' && lastChar === '"') || (firstChar === "'" && lastChar === "'")
+            ? bash_command.slice(1, -1)
+            : bash_command;
+        return {
+            nonInteractive: rawFlags['non-interactive'],
+            environment,
+            command: cleanCommand,
+        };
+    }
+    // eslint-disable-next-line async-protect/async-suffix
+    async catch(err) {
+        // when in non-interactive, make the behavior of this command a pure passthrough, outputting only the subprocess' stdout and stderr and exiting with the
+        // sub-command's exit status
+        if (this.isNonInteractive) {
+            process.exitCode = process.exitCode ?? err.status ?? 1;
+        }
+        else {
+            await super.catch(err);
+        }
+    }
+    async runCommandNonInteractiveWithEnvVarsAsync({ command, environmentVariables, }) {
+        await (0, spawn_async_1.default)(command, [], {
+            shell: true,
+            stdio: 'inherit',
+            env: {
+                ...process.env,
+                ...environmentVariables,
+            },
+        });
+    }
+    async runCommandWithEnvVarsAsync({ command, environmentVariables, }) {
+        log_1.default.log(`Running command: ${chalk_1.default.bold(command)}`);
+        const spawnPromise = (0, spawn_async_1.default)(command, [], {
+            shell: true,
+            stdio: ['inherit', 'pipe', 'pipe'],
+            env: {
+                ...process.env,
+                ...environmentVariables,
+            },
+        });
+        const { child: { stdout, stderr }, } = spawnPromise;
+        if (!stdout || !stderr) {
+            throw new Error(`Failed to spawn ${command}`);
+        }
+        stdout.on('data', data => {
+            for (const line of data.toString().trim().split('\n')) {
+                log_1.default.log(`${chalk_1.default.gray('[stdout]')} ${line}`);
+            }
+        });
+        stderr.on('data', data => {
+            for (const line of data.toString().trim().split('\n')) {
+                log_1.default.warn(`${chalk_1.default.gray('[stderr]')} ${line}`);
+            }
+        });
+        try {
+            await spawnPromise;
+        }
+        catch (error) {
+            log_1.default.error(`❌ ${chalk_1.default.bold(command)} failed`);
+            throw error;
+        }
+    }
+    async loadEnvironmentVariablesAsync({ graphqlClient, projectId, environment, nonInteractive, }) {
+        const environmentVariablesQueryResult = await EnvironmentVariablesQuery_1.EnvironmentVariablesQuery.byAppIdWithSensitiveAsync(graphqlClient, {
+            appId: projectId,
+            environment,
+        });
+        const nonSecretEnvironmentVariables = environmentVariablesQueryResult.filter(({ value }) => !!value);
+        if (!nonInteractive) {
+            if (nonSecretEnvironmentVariables.length > 0) {
+                log_1.default.log(`Environment variables with visibility "Plain text" and "Sensitive" loaded from the "${environment.toLowerCase()}" environment on EAS: ${nonSecretEnvironmentVariables
+                    .map(e => e.name)
+                    .join(', ')}.`);
+            }
+            else {
+                log_1.default.log(`No environment variables with visibility "Plain text" and "Sensitive" found for the "${environment.toLowerCase()}" environment on EAS.`);
+            }
+            log_1.default.newLine();
+        }
+        const environmentVariables = {};
+        for (const { name, value } of nonSecretEnvironmentVariables) {
+            if (value) {
+                environmentVariables[name] = value;
+            }
+        }
+        return environmentVariables;
+    }
+}
+exports.default = EnvExec;

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

@@ -0,0 +1,20 @@
+import EasCommand from '../../commandUtils/EasCommand';
+export default class EnvGet extends EasCommand {
+    static description: string;
+    static contextDefinition: {
+        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: {
+        'non-interactive': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        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>;
+        '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>;
+    };
+    runAsync(): Promise<void>;
+    private sanitizeInputs;
+}