@donotuse/eas-cli 18.5.0-rc.1

package/build/commandUtils/context/contextUtils/createGraphqlClient.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createGraphqlClient = createGraphqlClient;
+const tslib_1 = require("tslib");
+const core_1 = require("@urql/core");
+const exchange_retry_1 = require("@urql/exchange-retry");
+const node_fetch_1 = tslib_1.__importDefault(require("node-fetch"));
+const api_1 = require("../../../api");
+const fetch_1 = require("../../../fetch");
+function createGraphqlClient(authInfo) {
+    return (0, core_1.createClient)({
+        url: (0, api_1.getExpoApiBaseUrl)() + '/graphql',
+        exchanges: [
+            core_1.cacheExchange,
+            (0, exchange_retry_1.retryExchange)({
+                maxDelayMs: 4000,
+                retryIf: (err, operation) => {
+                    return !!(err &&
+                        !operation.context.noRetry &&
+                        (err.networkError ?? err.graphQLErrors.some(e => e?.extensions?.isTransient)));
+                },
+            }),
+            core_1.fetchExchange,
+        ],
+        // @ts-expect-error Type 'typeof fetch' is not assignable to type '(input: RequestInfo, init?: RequestInit | undefined) => Promise<Response>'.
+        fetch: node_fetch_1.default,
+        fetchOptions: () => {
+            const headers = {};
+            if (authInfo.accessToken) {
+                headers.authorization = `Bearer ${authInfo.accessToken}`;
+            }
+            else if (authInfo.sessionSecret) {
+                headers['expo-session'] = authInfo.sessionSecret;
+            }
+            return {
+                ...(fetch_1.httpsProxyAgent ? { agent: fetch_1.httpsProxyAgent } : {}),
+                headers,
+            };
+        },
+    });
+}

package/build/commandUtils/context/contextUtils/findProjectDirAndVerifyProjectSetupAsync.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @returns the project root directory.
+ *
+ * @deprecated Should not be used outside of context functions.
+ */
+export declare function findProjectRootAsync({ cwd, defaultToProcessCwd, }?: {
+    cwd?: string;
+    defaultToProcessCwd?: boolean;
+}): Promise<string>;
+/**
+ * Determine the project root directory and ensure some constraints about the project setup
+ * like CLI version and dependencies.
+ * @returns the project root directory
+ *
+ * @deprecated Should not be used outside of context functions.
+ */
+export declare function findProjectDirAndVerifyProjectSetupAsync({ cwd, }?: {
+    cwd?: string;
+}): Promise<string>;

package/build/commandUtils/context/contextUtils/findProjectDirAndVerifyProjectSetupAsync.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findProjectRootAsync = findProjectRootAsync;
+exports.findProjectDirAndVerifyProjectSetupAsync = findProjectDirAndVerifyProjectSetupAsync;
+const tslib_1 = require("tslib");
+const eas_json_1 = require("@expo/eas-json");
+const PackageManagerUtils = tslib_1.__importStar(require("@expo/package-manager"));
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const fs_extra_1 = tslib_1.__importDefault(require("fs-extra"));
+const getenv_1 = tslib_1.__importDefault(require("getenv"));
+const path_1 = tslib_1.__importDefault(require("path"));
+const pkg_dir_1 = tslib_1.__importDefault(require("pkg-dir"));
+const semver_1 = tslib_1.__importDefault(require("semver"));
+const log_1 = require("../../../log");
+const easCli_1 = require("../../../utils/easCli");
+const vcs_1 = require("../../../vcs");
+async function applyCliConfigAsync(projectDir) {
+    const easJsonAccessor = eas_json_1.EasJsonAccessor.fromProjectPath(projectDir);
+    const config = await eas_json_1.EasJsonUtils.getCliConfigAsync(easJsonAccessor);
+    const shouldSkipVersionCheck = getenv_1.default.boolish('EAS_SKIP_CLI_VERSION_CHECK', false);
+    if (!shouldSkipVersionCheck &&
+        config?.version &&
+        !semver_1.default.satisfies(easCli_1.easCliVersion, config.version)) {
+        throw new Error(`You are on eas-cli@${easCli_1.easCliVersion} which does not satisfy the CLI version constraint defined in eas.json (${config.version}).\n\nThis error probably means that you need update your eas-cli to a newer version.\nRun ${chalk_1.default.bold('npm install -g eas-cli')} to update the eas-cli to the latest version.`);
+    }
+}
+async function ensureEasCliIsNotInDependenciesAsync(projectDir) {
+    let printCliVersionWarning = false;
+    const consoleWarn = (msg) => {
+        if (msg) {
+            // eslint-disable-next-line no-console
+            console.warn(chalk_1.default.yellow(msg));
+        }
+        else {
+            // eslint-disable-next-line no-console
+            console.warn();
+        }
+    };
+    if (await isEasCliInDependenciesAsync(projectDir)) {
+        printCliVersionWarning = true;
+        consoleWarn(`Found ${chalk_1.default.bold('eas-cli')} in your project dependencies.`);
+    }
+    const maybeRepoRoot = PackageManagerUtils.resolveWorkspaceRoot(projectDir) ?? projectDir;
+    if (maybeRepoRoot !== projectDir && (await isEasCliInDependenciesAsync(maybeRepoRoot))) {
+        printCliVersionWarning = true;
+        consoleWarn(`Found ${chalk_1.default.bold('eas-cli')} in your monorepo dependencies.`);
+    }
+    if (printCliVersionWarning) {
+        consoleWarn(`It's recommended to use the ${chalk_1.default.bold('"cli.version"')} field in eas.json to enforce the ${chalk_1.default.bold('eas-cli')} version for your project.`);
+        consoleWarn((0, log_1.learnMore)('https://github.com/expo/eas-cli#enforcing-eas-cli-version-for-your-project'));
+        consoleWarn();
+    }
+}
+async function isEasCliInDependenciesAsync(dir) {
+    const packageJsonPath = path_1.default.join(dir, 'package.json');
+    const packageJson = JSON.parse(await fs_extra_1.default.readFile(packageJsonPath, 'utf8'));
+    return (packageJson?.dependencies?.['eas-cli'] !== undefined ||
+        packageJson?.devDependencies?.['eas-cli'] !== undefined);
+}
+/**
+ * @returns the project root directory.
+ *
+ * @deprecated Should not be used outside of context functions.
+ */
+async function findProjectRootAsync({ cwd, defaultToProcessCwd = false, } = {}) {
+    const projectRootDir = await (0, pkg_dir_1.default)(cwd);
+    if (!projectRootDir) {
+        if (!defaultToProcessCwd) {
+            throw new Error('Run this command inside a project directory.');
+        }
+        else {
+            return process.cwd();
+        }
+    }
+    else {
+        let vcsRoot;
+        try {
+            vcsRoot = path_1.default.normalize(await (0, vcs_1.resolveVcsClient)().getRootPathAsync());
+        }
+        catch { }
+        if (vcsRoot && vcsRoot.startsWith(projectRootDir) && vcsRoot !== projectRootDir) {
+            throw new Error(`package.json is outside of the current git repository (project root: ${projectRootDir}, git root: ${vcsRoot}.`);
+        }
+        return projectRootDir;
+    }
+}
+let ranEnsureEasCliIsNotInDependencies = false;
+/**
+ * Determine the project root directory and ensure some constraints about the project setup
+ * like CLI version and dependencies.
+ * @returns the project root directory
+ *
+ * @deprecated Should not be used outside of context functions.
+ */
+async function findProjectDirAndVerifyProjectSetupAsync({ cwd, } = {}) {
+    const projectDir = await findProjectRootAsync({ cwd });
+    await applyCliConfigAsync(projectDir);
+    if (!ranEnsureEasCliIsNotInDependencies) {
+        ranEnsureEasCliIsNotInDependencies = true;
+        await ensureEasCliIsNotInDependenciesAsync(projectDir);
+    }
+    return projectDir;
+}

package/build/commandUtils/context/contextUtils/getProjectIdAsync.d.ts

@@ -0,0 +1,38 @@
+import { ExpoConfig } from '@expo/config';
+import { Env } from '@expo/eas-build-job';
+import { ExpoGraphqlClient } from './createGraphqlClient';
+import SessionManager from '../../../user/SessionManager';
+import { Actor } from '../../../user/User';
+/**
+ * Save an EAS project ID to the appropriate field in the app config.
+ *
+ * @deprecated Should not be used outside of context functions except in the init command.
+ * @deprecated Starting from `@expo/config` from SDK 52, the `modifyConfigAsync` function is merging existing data. Once this is released, we can use that instead of manually merging.
+ */
+export declare function saveProjectIdToAppConfigAsync(projectDir: string, projectId: string, options?: {
+    env?: Env;
+}): Promise<void>;
+/**
+ * Get the EAS project ID from the app config. If the project ID is not set in the config,
+ * use the owner/slug to identify an EAS project on the server (asking for confirmation first),
+ * and attempt to save the EAS project ID to the appropriate field in the app config. If unable to
+ * save to the app config, throw an error.
+ *
+ * @returns the EAS project ID
+ *
+ * @deprecated Should not be used outside of context functions.
+ */
+export declare function getProjectIdAsync(sessionManager: SessionManager, exp: ExpoConfig, options: {
+    env?: Env;
+    nonInteractive: boolean;
+}): Promise<string>;
+export declare function validateOrSetProjectIdAsync({ exp, graphqlClient, actor, options, cwd, }: {
+    exp: ExpoConfig;
+    graphqlClient: ExpoGraphqlClient;
+    actor: Actor;
+    options: {
+        env?: Env;
+        nonInteractive: boolean;
+    };
+    cwd?: string;
+}): Promise<string>;

package/build/commandUtils/context/contextUtils/getProjectIdAsync.js

@@ -0,0 +1,139 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.saveProjectIdToAppConfigAsync = saveProjectIdToAppConfigAsync;
+exports.getProjectIdAsync = getProjectIdAsync;
+exports.validateOrSetProjectIdAsync = validateOrSetProjectIdAsync;
+const tslib_1 = require("tslib");
+const config_1 = require("@expo/config");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const semver_1 = tslib_1.__importDefault(require("semver"));
+const createGraphqlClient_1 = require("./createGraphqlClient");
+const findProjectDirAndVerifyProjectSetupAsync_1 = require("./findProjectDirAndVerifyProjectSetupAsync");
+const AppQuery_1 = require("../../../graphql/queries/AppQuery");
+const log_1 = tslib_1.__importStar(require("../../../log"));
+const ora_1 = require("../../../ora");
+const expoConfig_1 = require("../../../project/expoConfig");
+const fetchOrCreateProjectIDForWriteToConfigWithConfirmationAsync_1 = require("../../../project/fetchOrCreateProjectIDForWriteToConfigWithConfirmationAsync");
+const User_1 = require("../../../user/User");
+/**
+ * Save an EAS project ID to the appropriate field in the app config.
+ *
+ * @deprecated Should not be used outside of context functions except in the init command.
+ * @deprecated Starting from `@expo/config` from SDK 52, the `modifyConfigAsync` function is merging existing data. Once this is released, we can use that instead of manually merging.
+ */
+async function saveProjectIdToAppConfigAsync(projectDir, projectId, options = {}) {
+    // NOTE(cedric): we disable plugins to avoid writing plugin-generated content to `expo.extra`
+    const exp = await (0, expoConfig_1.getPrivateExpoConfigAsync)(projectDir, { skipPlugins: true, ...options });
+    const result = await (0, expoConfig_1.createOrModifyExpoConfigAsync)(projectDir, {
+        extra: { ...exp.extra, eas: { ...exp.extra?.eas, projectId } },
+    }, { skipSDKVersionRequirement: true });
+    switch (result.type) {
+        case 'success':
+            break;
+        case 'warn': {
+            log_1.default.warn();
+            log_1.default.warn(`Warning: Your project uses dynamic app configuration, and the EAS project ID can't automatically be added to it.`);
+            log_1.default.warn(chalk_1.default.dim('https://docs.expo.dev/workflow/configuration/#dynamic-configuration-with-appconfigjs'));
+            log_1.default.warn();
+            log_1.default.warn(`To complete the setup process, set "${chalk_1.default.bold('extra.eas.projectId')}" in your ${chalk_1.default.bold((0, config_1.getProjectConfigDescription)(projectDir))}:`);
+            log_1.default.warn();
+            log_1.default.warn(chalk_1.default.bold(JSON.stringify({ expo: { extra: { eas: { projectId } } } }, null, 2)));
+            log_1.default.warn();
+            throw new Error(result.message);
+        }
+        case 'fail':
+            throw new Error(result.message);
+        default:
+            throw new Error('Unexpected result type from modifyConfigAsync');
+    }
+}
+/**
+ * Get the EAS project ID from the app config. If the project ID is not set in the config,
+ * use the owner/slug to identify an EAS project on the server (asking for confirmation first),
+ * and attempt to save the EAS project ID to the appropriate field in the app config. If unable to
+ * save to the app config, throw an error.
+ *
+ * @returns the EAS project ID
+ *
+ * @deprecated Should not be used outside of context functions.
+ */
+async function getProjectIdAsync(sessionManager, exp, options) {
+    // all codepaths in this function require a logged-in user with access to the owning account
+    // since they either query the app via graphql or create it, which includes getting info about
+    // the owner
+    const { actor, authenticationInfo } = await sessionManager.ensureLoggedInAsync({
+        nonInteractive: options.nonInteractive,
+    });
+    const graphqlClient = (0, createGraphqlClient_1.createGraphqlClient)(authenticationInfo);
+    const projectId = await validateOrSetProjectIdAsync({ exp, graphqlClient, actor, options });
+    return projectId;
+}
+async function validateOrSetProjectIdAsync({ exp, graphqlClient, actor, options, cwd, }) {
+    const localProjectId = exp.extra?.eas?.projectId;
+    if (localProjectId) {
+        if (typeof localProjectId !== 'string') {
+            throw new Error(`Project config: "extra.eas.projectId" must be a string, found ${typeof localProjectId}. If you're not sure how to set it up on your own, remove the property entirely and it will be automatically configured on the next EAS CLI run.`);
+        }
+        // check that the local project ID matches account and slug
+        const appForProjectId = await AppQuery_1.AppQuery.byIdAsync(graphqlClient, localProjectId);
+        if (exp.owner && exp.owner !== appForProjectId.ownerAccount.name) {
+            throw new Error(`Project config: Owner of project identified by "extra.eas.projectId" (${appForProjectId.ownerAccount.name}) does not match owner specified in the "owner" field (${exp.owner}). ${(0, log_1.learnMore)('https://expo.fyi/eas-project-id')}`);
+        }
+        const sdkVersion = exp.sdkVersion;
+        // SDK 53 and above no longer require owner field in app config
+        if (sdkVersion && semver_1.default.satisfies(sdkVersion, '< 53.0.0')) {
+            const actorUsername = (0, User_1.getActorUsername)(actor);
+            if (!exp.owner && appForProjectId.ownerAccount.name !== actorUsername) {
+                if (actorUsername) {
+                    throw new Error(`Project config: Owner of project identified by "extra.eas.projectId" (${appForProjectId.ownerAccount.name}) does not match the logged in user (${actorUsername}) and the "owner" field is not specified. To ensure all libraries work correctly, "owner": "${appForProjectId.ownerAccount.name}" should be added to the project config, which can be done automatically by re-running "eas init". ${(0, log_1.learnMore)('https://expo.fyi/eas-project-id')}`);
+                }
+                else {
+                    // robot caller
+                    throw new Error(`Project config: Owner of project identified by "extra.eas.projectId" (${appForProjectId.ownerAccount.name}) must be specified in "owner" field when using a robot access token. To ensure all libraries work correctly, "owner": "${appForProjectId.ownerAccount.name}" should be added to the project config, which can be done automatically by re-running "eas init". ${(0, log_1.learnMore)('https://expo.fyi/eas-project-id')}`);
+                }
+            }
+        }
+        if (exp.slug && exp.slug !== appForProjectId.slug) {
+            throw new Error(`Project config: Slug for project identified by "extra.eas.projectId" (${appForProjectId.slug}) does not match the "slug" field (${exp.slug}). ${(0, log_1.learnMore)('https://expo.fyi/eas-project-id')}`);
+        }
+        return localProjectId;
+    }
+    const projectDir = await (0, findProjectDirAndVerifyProjectSetupAsync_1.findProjectRootAsync)({
+        cwd,
+    });
+    if (!projectDir) {
+        throw new Error('This command must be run inside a project directory.');
+    }
+    log_1.default.warn('EAS project not configured.');
+    const getDefaultAccountNameForEASProject = (exp, user) => {
+        if (exp.owner) {
+            return exp.owner;
+        }
+        switch (user.__typename) {
+            case 'User':
+                return user.username;
+            case 'SSOUser':
+                return user.username;
+            case 'PartnerActor':
+                return user.username;
+            case 'Robot':
+                throw new Error('Must configure EAS project by running "eas init" before using a robot user to manage the project.');
+        }
+    };
+    const projectId = await (0, fetchOrCreateProjectIDForWriteToConfigWithConfirmationAsync_1.fetchOrCreateProjectIDForWriteToConfigWithConfirmationAsync)(graphqlClient, {
+        accountName: getDefaultAccountNameForEASProject(exp, actor),
+        projectName: exp.slug,
+    }, {
+        nonInteractive: options.nonInteractive,
+    }, actor);
+    const spinner = (0, ora_1.ora)(`Linking local project to EAS project ${projectId}`).start();
+    try {
+        await saveProjectIdToAppConfigAsync(projectDir, projectId, options);
+        spinner.succeed(`Linked local project to EAS project ${projectId}`);
+    }
+    catch (e) {
+        spinner.fail();
+        throw e;
+    }
+    return projectId;
+}

package/build/commandUtils/context/contextUtils/loadServerSideEnvironmentVariablesAsync.d.ts

@@ -0,0 +1,6 @@
+import { ExpoGraphqlClient } from './createGraphqlClient';
+export declare function loadServerSideEnvironmentVariablesAsync({ environment, projectId, graphqlClient, }: {
+    environment: string;
+    projectId: string;
+    graphqlClient: ExpoGraphqlClient;
+}): Promise<Record<string, string>>;

package/build/commandUtils/context/contextUtils/loadServerSideEnvironmentVariablesAsync.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadServerSideEnvironmentVariablesAsync = loadServerSideEnvironmentVariablesAsync;
+const tslib_1 = require("tslib");
+const EnvironmentVariablesQuery_1 = require("../../../graphql/queries/EnvironmentVariablesQuery");
+const log_1 = tslib_1.__importDefault(require("../../../log"));
+const cachedServerSideEnvironmentVariables = {};
+async function loadServerSideEnvironmentVariablesAsync({ environment, projectId, graphqlClient, }) {
+    // don't load environment variables if they were already loaded while executing a command
+    const cachedEnvVarsForEnvironment = cachedServerSideEnvironmentVariables[environment];
+    if (cachedEnvVarsForEnvironment) {
+        return cachedEnvVarsForEnvironment;
+    }
+    const environmentVariables = await EnvironmentVariablesQuery_1.EnvironmentVariablesQuery.byAppIdWithSensitiveAsync(graphqlClient, {
+        appId: projectId,
+        environment,
+    });
+    const serverEnvVars = Object.fromEntries(environmentVariables
+        .filter(({ name, value }) => name && value)
+        .map(({ name, value }) => [name, value]));
+    if (Object.keys(serverEnvVars).length > 0) {
+        log_1.default.log(`Environment variables with visibility "Plain text" and "Sensitive" loaded from the "${environment}" environment on EAS: ${Object.keys(serverEnvVars).join(', ')}.`);
+    }
+    else {
+        log_1.default.log(`No environment variables with visibility "Plain text" and "Sensitive" found for the "${environment}" environment on EAS.`);
+    }
+    log_1.default.newLine();
+    cachedServerSideEnvironmentVariables[environment] = serverEnvVars;
+    return serverEnvVars;
+}

package/build/commandUtils/errors.d.ts

@@ -0,0 +1,3 @@
+export declare class EasCommandError extends Error {
+    constructor(message: string);
+}

package/build/commandUtils/errors.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EasCommandError = void 0;
+class EasCommandError extends Error {
+    // constructor is not useless, since the constructor for Error allows for optional `message`
+    // eslint-disable-next-line @typescript-eslint/no-useless-constructor
+    constructor(message) {
+        super(message);
+    }
+}
+exports.EasCommandError = EasCommandError;

package/build/commandUtils/experienceParser.d.ts

@@ -0,0 +1,6 @@
+export declare const isValidExperienceName: (experienceName: string) => boolean;
+export declare const experienceToAccountName: (experienceName: string) => string;
+export declare const fullNameToSlug: (fullName: string) => string | null;
+export declare const isValidSlugStrict: (slug: string) => boolean;
+export declare const FORBIDDEN_NAMES: string[];
+export declare function isSlugForbidden(slug: string): boolean;

package/build/commandUtils/experienceParser.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FORBIDDEN_NAMES = exports.isValidSlugStrict = exports.fullNameToSlug = exports.experienceToAccountName = exports.isValidExperienceName = void 0;
+exports.isSlugForbidden = isSlugForbidden;
+const tslib_1 = require("tslib");
+/**
+ * TODO: Move to eas-build repo
+ */
+const invariant_1 = tslib_1.__importDefault(require("invariant"));
+const EXPERIENCE_NAME_REGEX = /^@(.*?)\/(.*)/; // @<captureGroup1>/<captureGroup2>
+const SLUG_REGEX_STRICT = /^[a-zA-Z0-9_\\-]+$/; // from xdl-schemas slug
+const isValidExperienceName = (experienceName) => {
+    const matches = experienceName.match(EXPERIENCE_NAME_REGEX);
+    return matches !== null && matches[1].length > 0 && matches[2].length > 0;
+};
+exports.isValidExperienceName = isValidExperienceName;
+const experienceToAccountName = (experienceName) => {
+    const matches = experienceName.match(EXPERIENCE_NAME_REGEX);
+    const accountName = matches ? matches[1] : null;
+    (0, invariant_1.default)(accountName, `The experience name "${experienceName}" is malformed`);
+    return accountName;
+};
+exports.experienceToAccountName = experienceToAccountName;
+const fullNameToSlug = (fullName) => {
+    const match = fullName.match(EXPERIENCE_NAME_REGEX);
+    return match ? match[2] : null;
+};
+exports.fullNameToSlug = fullNameToSlug;
+const isValidSlugStrict = (slug) => SLUG_REGEX_STRICT.test(slug);
+exports.isValidSlugStrict = isValidSlugStrict;
+// keep this list in sync with our project creation CLI https://github.com/expo/expo/blob/main/packages/create-expo/src/Template.ts
+exports.FORBIDDEN_NAMES = [
+    'react-native',
+    'react',
+    'react-dom',
+    'react-native-web',
+    'expo',
+    'expo-router',
+];
+function isSlugForbidden(slug) {
+    return exports.FORBIDDEN_NAMES.includes(slug);
+}

package/build/commandUtils/flags.d.ts

@@ -0,0 +1,43 @@
+export declare function isNonInteractiveByDefault(): boolean;
+export declare const EasNonInteractiveAndJsonFlags: {
+    json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    'non-interactive': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+};
+export declare function resolveNonInteractiveAndJsonFlags(flags: {
+    json?: boolean;
+    'non-interactive'?: boolean;
+}): {
+    json: boolean;
+    nonInteractive: boolean;
+};
+export declare const EasEnvironmentFlagParameters: {
+    description: string;
+};
+export declare const EASEnvironmentFlag: {
+    environment: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+};
+export declare const EASMultiEnvironmentFlag: {
+    environment: import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+};
+export declare const EASVariableFormatFlag: {
+    format: import("@oclif/core/lib/interfaces").OptionFlag<"long" | "short", import("@oclif/core/lib/interfaces").CustomOptions>;
+};
+export declare const EASVariableVisibilityFlag: {
+    visibility: import("@oclif/core/lib/interfaces").OptionFlag<"plaintext" | "sensitive" | "secret" | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+};
+export type EASEnvironmentVariableScopeFlagValue = 'project' | 'account';
+export declare const EASEnvironmentVariableScopeFlag: {
+    scope: import("@oclif/core/lib/interfaces").OptionFlag<"project" | "account", import("@oclif/core/lib/interfaces").CustomOptions>;
+};
+export declare const EASNonInteractiveFlag: {
+    'non-interactive': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+};
+export declare const EasJsonOnlyFlag: {
+    json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+};
+export declare const EasUpdateEnvironmentFlag: {
+    environment: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+};
+export declare const EasUpdateEnvironmentRequiredFlag: {
+    environment: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+};

package/build/commandUtils/flags.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EasUpdateEnvironmentRequiredFlag = exports.EasUpdateEnvironmentFlag = exports.EasJsonOnlyFlag = exports.EASNonInteractiveFlag = exports.EASEnvironmentVariableScopeFlag = exports.EASVariableVisibilityFlag = exports.EASVariableFormatFlag = exports.EASMultiEnvironmentFlag = exports.EASEnvironmentFlag = exports.EasEnvironmentFlagParameters = exports.EasNonInteractiveAndJsonFlags = void 0;
+exports.isNonInteractiveByDefault = isNonInteractiveByDefault;
+exports.resolveNonInteractiveAndJsonFlags = resolveNonInteractiveAndJsonFlags;
+const core_1 = require("@oclif/core");
+const getenv_1 = require("getenv");
+function isNonInteractiveByDefault() {
+    return (0, getenv_1.boolish)('CI', false) || !process.stdin.isTTY;
+}
+exports.EasNonInteractiveAndJsonFlags = {
+    json: core_1.Flags.boolean({
+        description: 'Enable JSON output, non-JSON messages will be printed to stderr. Implies --non-interactive.',
+    }),
+    'non-interactive': core_1.Flags.boolean({
+        description: 'Run the command in non-interactive mode.',
+        default: () => Promise.resolve(isNonInteractiveByDefault()),
+        noCacheDefault: true,
+    }),
+};
+function resolveNonInteractiveAndJsonFlags(flags) {
+    const json = flags.json ?? false;
+    const nonInteractive = flags['non-interactive'] || json;
+    return { json, nonInteractive };
+}
+exports.EasEnvironmentFlagParameters = {
+    description: "Environment variable's environment, e.g. 'production', 'preview', 'development'",
+};
+exports.EASEnvironmentFlag = {
+    environment: core_1.Flags.string({
+        description: "Environment variable's environment, e.g. 'production', 'preview', 'development'",
+    }),
+};
+exports.EASMultiEnvironmentFlag = {
+    environment: core_1.Flags.string({
+        ...exports.EasEnvironmentFlagParameters,
+        multiple: true,
+    }),
+};
+exports.EASVariableFormatFlag = {
+    format: core_1.Flags.option({
+        description: 'Output format',
+        options: ['long', 'short'],
+        default: 'short',
+    })(),
+};
+exports.EASVariableVisibilityFlag = {
+    visibility: core_1.Flags.option({
+        description: 'Visibility of the variable',
+        options: ['plaintext', 'sensitive', 'secret'],
+    })(),
+};
+exports.EASEnvironmentVariableScopeFlag = {
+    scope: core_1.Flags.option({
+        description: 'Scope for the variable',
+        options: ['project', 'account'],
+        default: 'project',
+    })(),
+};
+exports.EASNonInteractiveFlag = {
+    'non-interactive': core_1.Flags.boolean({
+        description: 'Run the command in non-interactive mode.',
+        // eslint-disable-next-line async-protect/async-suffix
+        default: async () => {
+            return isNonInteractiveByDefault();
+        },
+        noCacheDefault: true,
+    }),
+};
+exports.EasJsonOnlyFlag = {
+    json: core_1.Flags.boolean({
+        description: 'Enable JSON output, non-JSON messages will be printed to stderr.',
+    }),
+};
+exports.EasUpdateEnvironmentFlag = {
+    environment: core_1.Flags.string({
+        description: 'Environment to use for the server-side defined EAS environment variables during command execution, e.g. "production", "preview", "development".',
+        required: false,
+        default: undefined,
+    }),
+};
+exports.EasUpdateEnvironmentRequiredFlag = {
+    environment: core_1.Flags.string({
+        description: 'Environment to use for the server-side defined EAS environment variables during command execution, e.g. "production", "preview", "development". Required for projects using Expo SDK 55 or greater.',
+        required: false,
+        default: undefined,
+    }),
+};

package/build/commandUtils/gating/FeatureGateEnvOverrides.d.ts

@@ -0,0 +1,7 @@
+import { FeatureGateKey } from './FeatureGateKey';
+export default class FeatureGateEnvOverrides {
+    private readonly map;
+    constructor();
+    isOverridden(key: FeatureGateKey): boolean;
+    getOverride(key: FeatureGateKey): boolean;
+}

package/build/commandUtils/gating/FeatureGateEnvOverrides.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const nullthrows_1 = tslib_1.__importDefault(require("nullthrows"));
+const env_1 = tslib_1.__importDefault(require("../../env"));
+function parseFeatureGateEnvVariableValue(value) {
+    if (!value) {
+        return [];
+    }
+    return value.split(',').map(v => v.trim());
+}
+class FeatureGateEnvOverrides {
+    map = new Map();
+    constructor() {
+        const overrideEnableGateKeys = new Set(parseFeatureGateEnvVariableValue(env_1.default.featureGateEnable));
+        const overrideDisableGateKeys = new Set(parseFeatureGateEnvVariableValue(env_1.default.featureGateDisable));
+        for (const overrideEnableKey of overrideEnableGateKeys) {
+            if (overrideDisableGateKeys.has(overrideEnableKey)) {
+                continue;
+            }
+            this.map.set(overrideEnableKey, true);
+        }
+        for (const overrideDisableGateKey of overrideDisableGateKeys) {
+            this.map.set(overrideDisableGateKey, false);
+        }
+    }
+    isOverridden(key) {
+        return this.map.has(key) ?? false;
+    }
+    getOverride(key) {
+        return (0, nullthrows_1.default)(this.map.get(key));
+    }
+}
+exports.default = FeatureGateEnvOverrides;

package/build/commandUtils/gating/FeatureGateKey.d.ts

@@ -0,0 +1,4 @@
+export declare enum FeatureGateKey {
+    TEST = "test"
+}
+export declare const featureGateDefaultValueWhenNoServerValue: Record<FeatureGateKey, boolean>;

package/build/commandUtils/gating/FeatureGateKey.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.featureGateDefaultValueWhenNoServerValue = exports.FeatureGateKey = void 0;
+var FeatureGateKey;
+(function (FeatureGateKey) {
+    // for tests
+    FeatureGateKey["TEST"] = "test";
+})(FeatureGateKey || (exports.FeatureGateKey = FeatureGateKey = {}));
+exports.featureGateDefaultValueWhenNoServerValue = {
+    [FeatureGateKey.TEST]: true,
+};

package/build/commandUtils/gating/FeatureGateTestOverrides.d.ts

@@ -0,0 +1,5 @@
+import { FeatureGateKey } from './FeatureGateKey';
+export declare const setOverride: (_key: FeatureGateKey, _enabled: boolean) => void;
+export declare const removeOverride: (_key: FeatureGateKey) => void;
+export declare const isOverridden: (_key: FeatureGateKey) => boolean;
+export declare const getOverride: (_key: FeatureGateKey) => boolean;