@donotuse/eas-cli 18.5.0-rc.1

package/build/project/android/gradleUtils.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_MODULE_NAME = void 0;
+exports.getAppBuildGradleAsync = getAppBuildGradleAsync;
+exports.resolveConfigValue = resolveConfigValue;
+exports.parseGradleCommand = parseGradleCommand;
+const tslib_1 = require("tslib");
+const config_plugins_1 = require("@expo/config-plugins");
+const fs_extra_1 = tslib_1.__importDefault(require("fs-extra"));
+const parser_1 = tslib_1.__importDefault(require("gradle-to-js/lib/parser"));
+exports.DEFAULT_MODULE_NAME = 'app';
+async function getAppBuildGradleAsync(projectDir) {
+    const buildGradlePath = config_plugins_1.AndroidConfig.Paths.getAppBuildGradleFilePath(projectDir);
+    const rawBuildGradle = await fs_extra_1.default.readFile(buildGradlePath, 'utf8');
+    // filter out any comments
+    // when comments are present, gradle-to-js fails to parse the file
+    const rawBuildGradleWithoutComments = rawBuildGradle
+        .split('\n')
+        .filter(line => !line.trim().startsWith('//'))
+        .join('\n');
+    return await parser_1.default.parseText(rawBuildGradleWithoutComments);
+}
+function resolveConfigValue(buildGradle, field, flavor) {
+    return ((flavor && buildGradle?.android?.productFlavors?.[flavor]?.[field]) ??
+        buildGradle?.android?.defaultConfig?.[field]);
+}
+/**
+ * Extract module name, buildType, and flavor from the gradle command.
+ *
+ * @param cmd can be any valid string that can be added after `./gradlew` call
+ * e.g.
+ *   - :app:buildDebug
+ *   - app:buildDebug
+ *   - buildDebug
+ *   - buildDebug --console verbose
+ * @param buildGradle is used to verify correct casing of the first letter in
+ * the flavor name
+ **/
+function parseGradleCommand(cmd, buildGradle) {
+    const flavorDimensions = typeof buildGradle.android?.flavorDimensions === 'string'
+        ? buildGradle.android.flavorDimensions.split(',')
+        : buildGradle.android?.flavorDimensions;
+    const hasFlavorDimensions = flavorDimensions && flavorDimensions.length > 1;
+    if (hasFlavorDimensions) {
+        throw new Error('flavorDimensions in build.gradle are not supported yet');
+    }
+    const flavors = new Set(Object.keys(buildGradle?.android?.productFlavors ?? {}));
+    // remove any params specified after command name
+    const [withoutParams] = cmd.split(' ');
+    // remove leading :
+    const rawCmd = withoutParams.startsWith(':') ? withoutParams.slice(1) : withoutParams;
+    // separate moduleName and rest of the definition
+    const splitCmd = rawCmd.split(':');
+    const [moduleName, taskName] = splitCmd.length > 1 ? [splitCmd[0], splitCmd[1]] : [undefined, splitCmd[0]];
+    const matchResult = taskName.match(/(build|bundle|assemble|package)(.*)([A-Z][a-z]+)/);
+    if (!matchResult) {
+        throw new Error(`Failed to parse gradle command: ${cmd}`);
+    }
+    let flavor;
+    if (matchResult[2]) {
+        const [firstLetter, rest] = [matchResult[2].slice(0, 1), matchResult[2].slice(1)];
+        // first letter casing is not known based on gradle task name
+        // so we need to check both options
+        const flavorOptions = [
+            firstLetter.toLowerCase().concat(rest),
+            firstLetter.toUpperCase().concat(rest),
+        ];
+        flavorOptions.forEach(option => {
+            if (flavors.has(option)) {
+                flavor = option;
+            }
+        });
+        if (!flavor) {
+            throw new Error(`flavor ${firstLetter.toLowerCase().concat(rest)} is not defined`);
+        }
+    }
+    const buildType = matchResult[3]
+        ? matchResult[3].charAt(0).toLowerCase() + matchResult[3].slice(1)
+        : undefined;
+    return {
+        moduleName,
+        flavor,
+        buildType,
+    };
+}

package/build/project/android/versions.d.ts

@@ -0,0 +1,3 @@
+export declare const VERSION_CODE_REQUIREMENTS = "versionCode needs to be a positive integer smaller or equal to 2100000000";
+export declare function isValidVersionCode(versionCode: string | number): boolean;
+export declare function getNextVersionCode(versionCode: string | number): number;

package/build/project/android/versions.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VERSION_CODE_REQUIREMENTS = void 0;
+exports.isValidVersionCode = isValidVersionCode;
+exports.getNextVersionCode = getNextVersionCode;
+const tslib_1 = require("tslib");
+const assert_1 = tslib_1.__importDefault(require("assert"));
+const MAX_VERSION_CODE = 2100000000;
+exports.VERSION_CODE_REQUIREMENTS = `versionCode needs to be a positive integer smaller or equal to ${MAX_VERSION_CODE}`;
+function isValidVersionCode(versionCode) {
+    const numericVersionCode = typeof versionCode === 'string' ? Number(versionCode) : versionCode;
+    return (Number.isInteger(numericVersionCode) &&
+        numericVersionCode <= MAX_VERSION_CODE &&
+        numericVersionCode > 0);
+}
+function getNextVersionCode(versionCode) {
+    (0, assert_1.default)(isValidVersionCode(versionCode), `Invalid versionCode ${versionCode}`);
+    const numericVersionCode = typeof versionCode === 'string' ? Number(versionCode) : versionCode;
+    if (numericVersionCode >= MAX_VERSION_CODE) {
+        throw new Error(`Invalid value: ${exports.VERSION_CODE_REQUIREMENTS}.`);
+    }
+    return numericVersionCode + 1;
+}

package/build/project/applicationIdentifier.d.ts

@@ -0,0 +1,16 @@
+import { ExpoConfig } from '@expo/config';
+import { Env, Platform } from '@expo/eas-build-job';
+import { BuildProfile } from '@expo/eas-json';
+import { ExpoGraphqlClient } from '../commandUtils/context/contextUtils/createGraphqlClient';
+import { Client } from '../vcs/vcs';
+export declare function getApplicationIdentifierAsync({ graphqlClient, projectDir, projectId, exp, buildProfile, platform, vcsClient, nonInteractive, env, }: {
+    graphqlClient: ExpoGraphqlClient;
+    projectDir: string;
+    projectId: string;
+    exp: ExpoConfig;
+    buildProfile: BuildProfile;
+    platform: Platform;
+    vcsClient: Client;
+    nonInteractive: boolean;
+    env: Env;
+}): Promise<string>;

package/build/project/applicationIdentifier.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getApplicationIdentifierAsync = getApplicationIdentifierAsync;
+const eas_build_job_1 = require("@expo/eas-build-job");
+const applicationId_1 = require("./android/applicationId");
+const gradle_1 = require("./android/gradle");
+const bundleIdentifier_1 = require("./ios/bundleIdentifier");
+const scheme_1 = require("./ios/scheme");
+const target_1 = require("./ios/target");
+const workflow_1 = require("./workflow");
+async function getApplicationIdentifierAsync({ graphqlClient, projectDir, projectId, exp, buildProfile, platform, vcsClient, nonInteractive, env, }) {
+    if (platform === eas_build_job_1.Platform.ANDROID) {
+        const profile = buildProfile;
+        const workflow = await (0, workflow_1.resolveWorkflowAsync)(projectDir, eas_build_job_1.Platform.ANDROID, vcsClient);
+        if (workflow === eas_build_job_1.Workflow.MANAGED) {
+            return await (0, applicationId_1.ensureApplicationIdIsDefinedForManagedProjectAsync)({
+                graphqlClient,
+                projectDir,
+                projectId,
+                exp,
+                vcsClient,
+                nonInteractive,
+            });
+        }
+        const gradleContext = await (0, gradle_1.resolveGradleBuildContextAsync)(projectDir, profile, vcsClient);
+        return await (0, applicationId_1.getApplicationIdAsync)(projectDir, exp, vcsClient, gradleContext);
+    }
+    else {
+        const workflow = await (0, workflow_1.resolveWorkflowAsync)(projectDir, eas_build_job_1.Platform.IOS, vcsClient);
+        const profile = buildProfile;
+        if (workflow === eas_build_job_1.Workflow.MANAGED) {
+            return await (0, bundleIdentifier_1.ensureBundleIdentifierIsDefinedForManagedProjectAsync)({
+                graphqlClient,
+                projectDir,
+                projectId,
+                exp,
+                vcsClient,
+                nonInteractive,
+            });
+        }
+        const xcodeBuildContext = await (0, scheme_1.resolveXcodeBuildContextAsync)({ exp, projectDir, nonInteractive: false, vcsClient }, profile);
+        const targets = await (0, target_1.resolveTargetsAsync)({
+            projectDir,
+            exp,
+            xcodeBuildContext,
+            env,
+            vcsClient,
+        });
+        const applicationTarget = (0, target_1.findApplicationTarget)(targets);
+        return await (0, bundleIdentifier_1.getBundleIdentifierAsync)(projectDir, exp, vcsClient, {
+            targetName: applicationTarget.targetName,
+            buildConfiguration: applicationTarget.buildConfiguration,
+        });
+    }
+}

package/build/project/customBuildConfig.d.ts

@@ -0,0 +1,13 @@
+import { Platform } from '@expo/eas-build-job';
+import { BuildProfile } from '@expo/eas-json';
+import { Client } from '../vcs/vcs';
+export interface CustomBuildConfigMetadata {
+    workflowName?: string;
+}
+export declare function validateCustomBuildConfigAsync({ profile, projectDir, vcsClient, }: {
+    projectDir: string;
+    profile: BuildProfile<Platform>;
+    vcsClient: Client;
+}): Promise<CustomBuildConfigMetadata | undefined>;
+export declare function getCustomBuildConfigPath(configFilename: string): string;
+export declare function getCustomBuildConfigPathForJob(configFilename: string): string;

package/build/project/customBuildConfig.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateCustomBuildConfigAsync = validateCustomBuildConfigAsync;
+exports.getCustomBuildConfigPath = getCustomBuildConfigPath;
+exports.getCustomBuildConfigPathForJob = getCustomBuildConfigPathForJob;
+const tslib_1 = require("tslib");
+const steps_1 = require("@expo/steps");
+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"));
+async function validateCustomBuildConfigAsync({ profile, projectDir, vcsClient, }) {
+    if (!profile.config) {
+        return undefined;
+    }
+    const relativeConfigPath = getCustomBuildConfigPath(profile.config);
+    const configPath = path_1.default.join(projectDir, relativeConfigPath);
+    if (!(await fs_extra_1.default.pathExists(configPath))) {
+        throw new Error(`Custom build configuration file ${chalk_1.default.bold(relativeConfigPath)} does not exist.`);
+    }
+    const rootDir = path_1.default.normalize(await vcsClient.getRootPathAsync());
+    if (await vcsClient.isFileIgnoredAsync(path_1.default.relative(rootDir, configPath))) {
+        throw new Error(`Custom build configuration file ${chalk_1.default.bold(relativeConfigPath)} is ignored by your version control system or .easignore. Remove it from the ignore list to successfully create custom build.`);
+    }
+    try {
+        const config = await (0, steps_1.readAndValidateBuildConfigFromPathAsync)(configPath, {
+            skipNamespacedFunctionsOrFunctionGroupsCheck: true,
+        });
+        return {
+            workflowName: config.build.name,
+        };
+    }
+    catch (err) {
+        if (err instanceof steps_1.errors.BuildConfigYAMLError) {
+            throw new Error(`Custom build configuration file ${chalk_1.default.bold(relativeConfigPath)} contains invalid YAML.\n\n${err.message}`);
+        }
+        else if (err instanceof steps_1.errors.BuildConfigError) {
+            throw new Error(`Custom build configuration file ${chalk_1.default.bold(relativeConfigPath)} contains invalid configuration. Please check the docs!\n${err.message}`);
+        }
+        else {
+            throw err;
+        }
+    }
+}
+function getCustomBuildConfigPath(configFilename) {
+    return path_1.default.join('.eas/build', configFilename);
+}
+function getCustomBuildConfigPathForJob(configFilename) {
+    return path_1.default.posix.join('.eas/build', configFilename);
+}

package/build/project/discourageExpoGoForProdAsync.d.ts

@@ -0,0 +1,4 @@
+import type { ProfileData } from '../utils/profiles';
+import type { Client } from '../vcs/vcs';
+export declare function discourageExpoGoForProdAsync(buildProfiles: ProfileData<'build'>[] | undefined, projectDir: string, vcsClient: Client): Promise<void>;
+export declare function detectExpoGoProdBuildAsync(buildProfiles: ProfileData<'build'>[] | undefined, projectDir: string, vcsClient: Client): Promise<boolean>;

package/build/project/discourageExpoGoForProdAsync.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.discourageExpoGoForProdAsync = discourageExpoGoForProdAsync;
+exports.detectExpoGoProdBuildAsync = detectExpoGoProdBuildAsync;
+const tslib_1 = require("tslib");
+const eas_build_job_1 = require("@expo/eas-build-job");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const getenv_1 = tslib_1.__importDefault(require("getenv"));
+const workflow_1 = require("./workflow");
+const devClient_1 = require("../build/utils/devClient");
+const log_1 = tslib_1.__importStar(require("../log"));
+const suppressionEnvVarName = 'EAS_BUILD_NO_EXPO_GO_WARNING';
+async function discourageExpoGoForProdAsync(buildProfiles, projectDir, vcsClient) {
+    try {
+        const isExpoGoProdBuild = await detectExpoGoProdBuildAsync(buildProfiles, projectDir, vcsClient);
+        if (!isExpoGoProdBuild) {
+            return;
+        }
+        log_1.default.newLine();
+        log_1.default.warn(`⚠️ Detected that your app uses Expo Go for development, this is not recommended when building production apps.`);
+        log_1.default.warn((0, log_1.learnMore)('https://expo.fyi/why-not-build-expo-go-for-production', {
+            dim: false,
+        }));
+        log_1.default.warn(chalk_1.default.dim(`To suppress this warning, set ${chalk_1.default.bold(`${suppressionEnvVarName}=true`)}.`));
+        log_1.default.newLine();
+    }
+    catch (err) {
+        log_1.default.isDebug && log_1.default.warn('Error detecting whether Expo Go is used:', err);
+    }
+}
+async function detectExpoGoProdBuildAsync(buildProfiles, projectDir, vcsClient) {
+    const shouldSuppressWarning = getenv_1.default.boolish(suppressionEnvVarName, false);
+    const isProductionBuild = buildProfiles?.map(it => it.profileName).includes('production');
+    if (shouldSuppressWarning || !isProductionBuild) {
+        return false;
+    }
+    const hasExpoDevClient = (0, devClient_1.isExpoDevClientInstalled)(projectDir);
+    if (hasExpoDevClient) {
+        return false;
+    }
+    return await checkIfManagedWorkflowAsync(projectDir, vcsClient);
+}
+async function checkIfManagedWorkflowAsync(projectDir, vcsClient) {
+    const workflows = await (0, workflow_1.resolveWorkflowPerPlatformAsync)(projectDir, vcsClient);
+    return workflows.android === eas_build_job_1.Workflow.MANAGED && workflows.ios === eas_build_job_1.Workflow.MANAGED;
+}

package/build/project/expoConfig.d.ts

@@ -0,0 +1,19 @@
+import { ExpoConfig, modifyConfigAsync } from '@expo/config';
+import { Env } from '@expo/eas-build-job';
+export type PublicExpoConfig = Omit<ExpoConfig, '_internal' | 'hooks' | 'ios' | 'android' | 'updates'> & {
+    ios?: Omit<ExpoConfig['ios'], 'config'>;
+    android?: Omit<ExpoConfig['android'], 'config'>;
+    updates?: Omit<ExpoConfig['updates'], 'codeSigningCertificate' | 'codeSigningMetadata'>;
+};
+export interface ExpoConfigOptions {
+    env?: Env;
+    skipSDKVersionRequirement?: boolean;
+    skipPlugins?: boolean;
+}
+export declare function createOrModifyExpoConfigAsync(projectDir: string, exp: Partial<ExpoConfig>, readOptions?: {
+    skipSDKVersionRequirement?: boolean;
+}): ReturnType<typeof modifyConfigAsync>;
+export declare function getPrivateExpoConfigAsync(projectDir: string, opts?: ExpoConfigOptions): Promise<ExpoConfig>;
+export declare function ensureExpoConfigExists(projectDir: string): void;
+export declare function isUsingStaticExpoConfig(projectDir: string): boolean;
+export declare function getPublicExpoConfigAsync(projectDir: string, opts?: ExpoConfigOptions): Promise<PublicExpoConfig>;

package/build/project/expoConfig.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createOrModifyExpoConfigAsync = createOrModifyExpoConfigAsync;
+exports.getPrivateExpoConfigAsync = getPrivateExpoConfigAsync;
+exports.ensureExpoConfigExists = ensureExpoConfigExists;
+exports.isUsingStaticExpoConfig = isUsingStaticExpoConfig;
+exports.getPublicExpoConfigAsync = getPublicExpoConfigAsync;
+const tslib_1 = require("tslib");
+const config_1 = require("@expo/config");
+const spawn_async_1 = tslib_1.__importDefault(require("@expo/spawn-async"));
+const fs_extra_1 = tslib_1.__importDefault(require("fs-extra"));
+const joi_1 = tslib_1.__importDefault(require("joi"));
+const path_1 = tslib_1.__importDefault(require("path"));
+const projectUtils_1 = require("./projectUtils");
+const log_1 = tslib_1.__importDefault(require("../log"));
+async function createOrModifyExpoConfigAsync(projectDir, exp, readOptions) {
+    ensureExpoConfigExists(projectDir);
+    if (readOptions) {
+        return await (0, config_1.modifyConfigAsync)(projectDir, exp, readOptions);
+    }
+    else {
+        return await (0, config_1.modifyConfigAsync)(projectDir, exp);
+    }
+}
+let wasExpoConfigWarnPrinted = false;
+async function getExpoConfigInternalAsync(projectDir, opts = {}) {
+    const originalProcessEnv = process.env;
+    try {
+        process.env = {
+            ...process.env,
+            ...opts.env,
+        };
+        let exp;
+        if ((0, projectUtils_1.isExpoInstalled)(projectDir)) {
+            try {
+                const { stdout } = await (0, spawn_async_1.default)('npx', ['expo', 'config', '--json', ...(opts.isPublicConfig ? ['--type', 'public'] : [])], {
+                    cwd: projectDir,
+                    env: {
+                        ...process.env,
+                        ...opts.env,
+                        EXPO_NO_DOTENV: '1',
+                    },
+                });
+                exp = JSON.parse(stdout);
+            }
+            catch (err) {
+                if (!wasExpoConfigWarnPrinted) {
+                    log_1.default.warn(`Failed to read the app config from the project using "npx expo config" command: ${err.message}.`);
+                    log_1.default.warn('Falling back to the version of "@expo/config" shipped with the EAS CLI.');
+                    wasExpoConfigWarnPrinted = true;
+                }
+                exp = (0, config_1.getConfig)(projectDir, {
+                    skipSDKVersionRequirement: true,
+                    ...(opts.isPublicConfig ? { isPublicConfig: true } : {}),
+                    ...(opts.skipPlugins ? { skipPlugins: true } : {}),
+                }).exp;
+            }
+        }
+        else {
+            exp = (0, config_1.getConfig)(projectDir, {
+                skipSDKVersionRequirement: true,
+                ...(opts.isPublicConfig ? { isPublicConfig: true } : {}),
+                ...(opts.skipPlugins ? { skipPlugins: true } : {}),
+            }).exp;
+        }
+        const { error } = MinimalAppConfigSchema.validate(exp, {
+            allowUnknown: true,
+            abortEarly: true,
+        });
+        if (error) {
+            throw new Error(`Invalid app config.\n${error.message}`);
+        }
+        return exp;
+    }
+    finally {
+        process.env = originalProcessEnv;
+    }
+}
+const MinimalAppConfigSchema = joi_1.default.object({
+    slug: joi_1.default.string().required(),
+    name: joi_1.default.string().required(),
+    version: joi_1.default.string(),
+    android: joi_1.default.object({
+        versionCode: joi_1.default.number().integer(),
+    }),
+    ios: joi_1.default.object({
+        buildNumber: joi_1.default.string(),
+    }),
+});
+async function getPrivateExpoConfigAsync(projectDir, opts = {}) {
+    ensureExpoConfigExists(projectDir);
+    return await getExpoConfigInternalAsync(projectDir, { ...opts, isPublicConfig: false });
+}
+function ensureExpoConfigExists(projectDir) {
+    const paths = (0, config_1.getConfigFilePaths)(projectDir);
+    if (!paths?.staticConfigPath && !paths?.dynamicConfigPath) {
+        // eslint-disable-next-line node/no-sync
+        fs_extra_1.default.writeFileSync(path_1.default.join(projectDir, 'app.json'), JSON.stringify({ expo: {} }, null, 2));
+    }
+}
+function isUsingStaticExpoConfig(projectDir) {
+    const paths = (0, config_1.getConfigFilePaths)(projectDir);
+    return !!(paths.staticConfigPath?.endsWith('app.json') && !paths.dynamicConfigPath);
+}
+async function getPublicExpoConfigAsync(projectDir, opts = {}) {
+    ensureExpoConfigExists(projectDir);
+    return await getExpoConfigInternalAsync(projectDir, { ...opts, isPublicConfig: true });
+}

package/build/project/expoSdk.d.ts

@@ -0,0 +1,3 @@
+import { Platform } from '@expo/eas-build-job';
+import { BuildContext } from '../build/context';
+export declare function checkExpoSdkIsSupportedAsync(ctx: BuildContext<Platform>): Promise<void>;

package/build/project/expoSdk.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkExpoSdkIsSupportedAsync = checkExpoSdkIsSupportedAsync;
+const tslib_1 = require("tslib");
+const eas_build_job_1 = require("@expo/eas-build-job");
+const core_1 = require("@oclif/core");
+const assert_1 = tslib_1.__importDefault(require("assert"));
+const semver_1 = tslib_1.__importDefault(require("semver"));
+const log_1 = tslib_1.__importDefault(require("../log"));
+const prompts_1 = require("../prompts");
+const SUPPORTED_EXPO_SDK_VERSIONS = '>= 41.0.0';
+(0, assert_1.default)(semver_1.default.validRange(SUPPORTED_EXPO_SDK_VERSIONS), 'Must be a valid version range');
+async function checkExpoSdkIsSupportedAsync(ctx) {
+    (0, assert_1.default)(ctx.workflow === eas_build_job_1.Workflow.MANAGED, 'Must be a managed workflow project');
+    if (ctx.exp.sdkVersion && semver_1.default.satisfies(ctx.exp.sdkVersion, SUPPORTED_EXPO_SDK_VERSIONS)) {
+        return;
+    }
+    const unsupportedSdkMessage = 'EAS Build does not officially support building managed project with Expo SDK < 41.';
+    if (ctx.nonInteractive) {
+        log_1.default.warn(`${unsupportedSdkMessage} Proceeding because you are running in non-interactive mode.`);
+        return;
+    }
+    const proceed = await (0, prompts_1.confirmAsync)({
+        message: `${unsupportedSdkMessage} Do you want to proceed?`,
+    });
+    if (!proceed) {
+        core_1.Errors.exit(1);
+    }
+}

package/build/project/fetchOrCreateProjectIDForWriteToConfigWithConfirmationAsync.d.ts

@@ -0,0 +1,21 @@
+import { ExpoGraphqlClient } from '../commandUtils/context/contextUtils/createGraphqlClient';
+import { Actor } from '../user/User';
+/**
+ * 1. Looks for an existing project on EAS servers. If found, ask the user whether this is the
+ *    project they would like to link. If yes, return that. If not, throw.
+ * 2. If no existing project is found, ask the user whether they would like to register a new one.
+ *    If yes, register and return that. If not, throw.
+ */
+export declare function fetchOrCreateProjectIDForWriteToConfigWithConfirmationAsync(graphqlClient: ExpoGraphqlClient, projectInfo: {
+    accountName: string;
+    projectName: string;
+}, options: {
+    nonInteractive: boolean;
+}, actor: Actor): Promise<string>;
+/**
+ * Finds project by `@accountName/slug` and returns its ID, return null if the project does not exist.
+ * @param accountName account name
+ * @param slug project slug
+ * @returns A promise resolving to Project ID, null if it doesn't exist
+ */
+export declare function findProjectIdByAccountNameAndSlugNullableAsync(graphqlClient: ExpoGraphqlClient, accountName: string, slug: string): Promise<string | null>;

package/build/project/fetchOrCreateProjectIDForWriteToConfigWithConfirmationAsync.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchOrCreateProjectIDForWriteToConfigWithConfirmationAsync = fetchOrCreateProjectIDForWriteToConfigWithConfirmationAsync;
+exports.findProjectIdByAccountNameAndSlugNullableAsync = findProjectIdByAccountNameAndSlugNullableAsync;
+const tslib_1 = require("tslib");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const url_1 = require("../build/utils/url");
+const generated_1 = require("../graphql/generated");
+const AppMutation_1 = require("../graphql/mutations/AppMutation");
+const AppQuery_1 = require("../graphql/queries/AppQuery");
+const log_1 = require("../log");
+const ora_1 = require("../ora");
+const prompts_1 = require("../prompts");
+/**
+ * 1. Looks for an existing project on EAS servers. If found, ask the user whether this is the
+ *    project they would like to link. If yes, return that. If not, throw.
+ * 2. If no existing project is found, ask the user whether they would like to register a new one.
+ *    If yes, register and return that. If not, throw.
+ */
+async function fetchOrCreateProjectIDForWriteToConfigWithConfirmationAsync(graphqlClient, projectInfo, options, actor) {
+    const { accountName, projectName } = projectInfo;
+    const projectFullName = `@${accountName}/${projectName}`;
+    if (options.nonInteractive) {
+        throw new Error(`Must configure EAS project by running 'eas init' before this command can be run in non-interactive mode.`);
+    }
+    const allAccounts = actor.accounts;
+    const accountNamesWhereUserHasSufficientPublishPermissions = new Set(allAccounts
+        .filter(a => a.users.find(it => it.actor.id === actor.id)?.role !== generated_1.Role.ViewOnly)
+        .map(it => it.name));
+    const account = allAccounts.find(a => a.name === accountName);
+    if (!account) {
+        throw new Error(`You must have access to the ${accountName} account to configure this EAS project.`);
+    }
+    const projectIdOnServer = await findProjectIdByAccountNameAndSlugNullableAsync(graphqlClient, accountName, projectName);
+    if (projectIdOnServer) {
+        const affirmedLink = await (0, prompts_1.confirmAsync)({
+            message: `Existing EAS project found for ${projectFullName} (id = ${projectIdOnServer}). Configure this project?`,
+        });
+        if (!affirmedLink) {
+            throw new Error(`EAS project ID configuration canceled for ${projectFullName}. Run 'eas init' to configure.`);
+        }
+        return projectIdOnServer;
+    }
+    if (!accountNamesWhereUserHasSufficientPublishPermissions.has(accountName)) {
+        throw new Error(`You don't have permission to create a new project on the ${accountName} account and no matching project already exists on the account.`);
+    }
+    const affirmedCreate = await (0, prompts_1.confirmAsync)({
+        message: `Would you like to automatically create an EAS project for ${projectFullName}?`,
+    });
+    if (!affirmedCreate) {
+        throw new Error(`EAS project ID configuration canceled for ${projectFullName}. Run 'eas init' to configure.`);
+    }
+    const projectDashboardUrl = (0, url_1.getProjectDashboardUrl)(accountName, projectName);
+    const projectLink = (0, log_1.link)(projectDashboardUrl, { text: projectFullName });
+    const spinner = (0, ora_1.ora)(`Creating ${chalk_1.default.bold(projectFullName)} on EAS`).start();
+    try {
+        const id = await AppMutation_1.AppMutation.createAppAsync(graphqlClient, {
+            accountId: account.id,
+            projectName,
+        });
+        spinner.succeed(`Created ${chalk_1.default.bold(projectLink)} on EAS`);
+        return id;
+    }
+    catch (err) {
+        spinner.fail();
+        throw err;
+    }
+}
+/**
+ * Finds project by `@accountName/slug` and returns its ID, return null if the project does not exist.
+ * @param accountName account name
+ * @param slug project slug
+ * @returns A promise resolving to Project ID, null if it doesn't exist
+ */
+async function findProjectIdByAccountNameAndSlugNullableAsync(graphqlClient, accountName, slug) {
+    try {
+        const { id } = await AppQuery_1.AppQuery.byFullNameAsync(graphqlClient, `@${accountName}/${slug}`);
+        return id;
+    }
+    catch (err) {
+        if (err.graphQLErrors?.some((it) => it.extensions?.errorCode !== 'EXPERIENCE_NOT_FOUND')) {
+            throw err;
+        }
+        return null;
+    }
+}

package/build/project/ios/bundleIdentifier.d.ts

@@ -0,0 +1,22 @@
+import { ExpoConfig } from '@expo/config';
+import { ExpoGraphqlClient } from '../../commandUtils/context/contextUtils/createGraphqlClient';
+import { Client } from '../../vcs/vcs';
+export declare const INVALID_BUNDLE_IDENTIFIER_MESSAGE = "Invalid format of iOS bundle identifier. Only alphanumeric characters, '.' and '-' are allowed, and each '.' must be followed by a letter.";
+export declare function ensureBundleIdentifierIsDefinedForManagedProjectAsync({ graphqlClient, projectDir, projectId, exp, vcsClient, nonInteractive, }: {
+    graphqlClient: ExpoGraphqlClient;
+    projectDir: string;
+    projectId: string;
+    exp: ExpoConfig;
+    vcsClient: Client;
+    nonInteractive: boolean;
+}): Promise<string>;
+export declare class AmbiguousBundleIdentifierError extends Error {
+    constructor(message?: string);
+}
+export declare function getBundleIdentifierAsync(projectDir: string, exp: ExpoConfig, vcsClient: Client, xcodeContext?: {
+    targetName?: string;
+    buildConfiguration?: string;
+}): Promise<string>;
+export declare function isBundleIdentifierValid(bundleIdentifier: string): boolean;
+export declare function warnIfBundleIdentifierDefinedInAppConfigForBareWorkflowProject(projectDir: string, exp: ExpoConfig): void;
+export declare function isWildcardBundleIdentifier(bundleIdentifier: string): boolean;