eas-cli 14.4.1 → 14.6.0

package/build/graphql/types/Fingerprint.js

@@ -8,5 +8,23 @@ exports.FingerprintFragmentNode = (0, graphql_tag_1.default) `
     id
     hash
     debugInfoUrl
+    builds(first: 1) {
+      edges {
+        node {
+          id
+          ... on Build {
+            platform
+          }
+        }
+      }
+    }
+    updates(first: 1) {
+      edges {
+        node {
+          id
+          platform
+        }
+      }
+    }
   }
 `;

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

@@ -0,0 +1,7 @@
+import { ExpoConfig } from '@expo/config';
+/** Non-exempt encryption must be set on every build in App Store Connect, we move it to before the build process to attempt only setting it once for the entire life-cycle of the project. */
+export declare function ensureNonExemptEncryptionIsDefinedForManagedProjectAsync({ projectDir, exp, nonInteractive, }: {
+    projectDir: string;
+    exp: ExpoConfig;
+    nonInteractive: boolean;
+}): Promise<void>;

package/build/project/ios/exemptEncryption.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureNonExemptEncryptionIsDefinedForManagedProjectAsync = void 0;
+const tslib_1 = require("tslib");
+const config_1 = require("@expo/config");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const log_1 = tslib_1.__importStar(require("../../log"));
+const prompts_1 = require("../../prompts");
+/** Non-exempt encryption must be set on every build in App Store Connect, we move it to before the build process to attempt only setting it once for the entire life-cycle of the project. */
+async function ensureNonExemptEncryptionIsDefinedForManagedProjectAsync({ projectDir, exp, nonInteractive, }) {
+    // TODO: We could add bare workflow support in the future.
+    // TODO: We could add wizard support for non-exempt encryption in the future.
+    if (exp.ios?.infoPlist?.ITSAppUsesNonExemptEncryption == null) {
+        await configureNonExemptEncryptionAsync({
+            projectDir,
+            exp,
+            nonInteractive,
+        });
+    }
+    else {
+        log_1.default.debug(`ITSAppUsesNonExemptEncryption is defined in the app config.`);
+    }
+}
+exports.ensureNonExemptEncryptionIsDefinedForManagedProjectAsync = ensureNonExemptEncryptionIsDefinedForManagedProjectAsync;
+async function configureNonExemptEncryptionAsync({ projectDir, exp, nonInteractive, }) {
+    const description = (0, config_1.getProjectConfigDescription)(projectDir);
+    if (nonInteractive) {
+        log_1.default.warn((0, chalk_1.default) `${description} is missing {bold ios.infoPlist.ITSAppUsesNonExemptEncryption} boolean. Manual configuration is required in App Store Connect before the app can be tested.`);
+    }
+    let onlyExemptEncryption = await (0, prompts_1.confirmAsync)({
+        message: `iOS app only uses standard/exempt encryption? ${chalk_1.default.dim((0, log_1.learnMore)('https://developer.apple.com/documentation/Security/complying-with-encryption-export-regulations'))}`,
+        initial: true,
+    });
+    if (!onlyExemptEncryption) {
+        const confirm = await (0, prompts_1.confirmAsync)({
+            message: `Are you sure your app uses non-exempt encryption? Selecting 'Yes' will require annual self-classification reports for the US government.`,
+            initial: true,
+        });
+        if (!confirm) {
+            log_1.default.warn((0, chalk_1.default) `Set {bold ios.infoPlist.ITSAppUsesNonExemptEncryption} in ${description} to release Apple builds faster.`);
+            onlyExemptEncryption = true;
+        }
+    }
+    const ITSAppUsesNonExemptEncryption = !onlyExemptEncryption;
+    // Only set this value if the answer is no, this enables developers to see the more in-depth prompt in App Store Connect. They can set the value manually in the app.json to avoid the EAS prompt in subsequent builds.
+    if (ITSAppUsesNonExemptEncryption) {
+        log_1.default.warn(`You'll need to manually configure the encryption status in App Store Connect before your build can be tested.`);
+        return;
+    }
+    // NOTE: Is is it possible to assert that the config needs to be modifiable before building the app?
+    const modification = await (0, config_1.modifyConfigAsync)(projectDir, {
+        ios: {
+            ...(exp.ios ?? {}),
+            infoPlist: {
+                ...(exp.ios?.infoPlist ?? {}),
+                ITSAppUsesNonExemptEncryption,
+            },
+        },
+    }, {
+        skipSDKVersionRequirement: true,
+    });
+    if (modification.type !== 'success') {
+        log_1.default.log();
+        if (modification.type === 'warn') {
+            // The project is using a dynamic config, give the user a helpful log and bail out.
+            log_1.default.log(chalk_1.default.yellow(modification.message));
+        }
+        const edits = {
+            ios: {
+                infoPlist: {
+                    ITSAppUsesNonExemptEncryption,
+                },
+            },
+        };
+        log_1.default.log(chalk_1.default.cyan(`Add the following to ${description}:`));
+        log_1.default.log();
+        log_1.default.log(JSON.stringify(edits, null, 2));
+        log_1.default.log();
+    }
+}

package/build/project/publish.d.ts

@@ -145,11 +145,11 @@ export declare function getUpdateMessageForCommandAsync(vcsClient: Client, { upd
 export declare const defaultPublishPlatforms: UpdatePublishPlatform[];
 export type RuntimeVersionInfo = {
     runtimeVersion: string;
-    fingerprint: {
+    expoUpdatesRuntimeFingerprint: {
         fingerprintSources: object[];
         isDebugFingerprintSource: boolean;
     } | null;
-    fingerprintHash: string | null;
+    expoUpdatesRuntimeFingerprintHash: string | null;
 };
 type FingerprintInfoGroup = {
     [key in UpdatePublishPlatform]?: FingerprintInfo;
@@ -179,13 +179,13 @@ export declare function maybeCalculateFingerprintForRuntimeVersionInfoObjectsWit
     graphqlClient: ExpoGraphqlClient;
     runtimeToPlatformsAndFingerprintInfoAndFingerprintSourceMapping: (RuntimeVersionInfo & {
         platforms: UpdatePublishPlatform[];
-        fingerprintSource: FingerprintSource | null;
+        expoUpdatesRuntimeFingerprintSource: FingerprintSource | null;
     })[];
     workflowsByPlatform: Record<Platform, Workflow>;
     env: Env | undefined;
 }): Promise<(RuntimeVersionInfo & {
     platforms: UpdatePublishPlatform[];
-    fingerprintSource: FingerprintSource | null;
+    expoUpdatesRuntimeFingerprintSource: FingerprintSource | null;
     fingerprintInfoGroup: FingerprintInfoGroup;
 })[]>;
 export declare const platformDisplayNames: Record<UpdatePublishPlatform, string>;

package/build/project/publish.js

@@ -520,8 +520,8 @@ async function getRuntimeVersionInfoForPlatformAsync({ exp, platform, workflow,
     }
     return {
         runtimeVersion: resolvedRuntimeVersion,
-        fingerprint: null,
-        fingerprintHash: null,
+        expoUpdatesRuntimeFingerprint: null,
+        expoUpdatesRuntimeFingerprintHash: null,
     };
 }
 function getRuntimeToPlatformsAndFingerprintInfoMappingFromRuntimeVersionInfoObjects(runtimeVersionInfoObjects) {
@@ -530,14 +530,14 @@ function getRuntimeToPlatformsAndFingerprintInfoMappingFromRuntimeVersionInfoObj
         return {
             runtimeVersion,
             platforms: runtimeVersionInfoObjects.map(runtimeVersionInfoObject => runtimeVersionInfoObject.platform),
-            fingerprint: runtimeVersionInfoObjects.map(runtimeVersionInfoObject => runtimeVersionInfoObject.runtimeVersionInfo.fingerprint)[0] ?? null,
-            fingerprintHash: runtimeVersionInfoObjects.map(runtimeVersionInfoObject => runtimeVersionInfoObject.runtimeVersionInfo.fingerprintHash)[0] ?? null,
+            expoUpdatesRuntimeFingerprint: runtimeVersionInfoObjects.map(runtimeVersionInfoObject => runtimeVersionInfoObject.runtimeVersionInfo.expoUpdatesRuntimeFingerprint)[0] ?? null,
+            expoUpdatesRuntimeFingerprintHash: runtimeVersionInfoObjects.map(runtimeVersionInfoObject => runtimeVersionInfoObject.runtimeVersionInfo.expoUpdatesRuntimeFingerprintHash)[0] ?? null,
         };
     });
 }
 exports.getRuntimeToPlatformsAndFingerprintInfoMappingFromRuntimeVersionInfoObjects = getRuntimeToPlatformsAndFingerprintInfoMappingFromRuntimeVersionInfoObjects;
 async function maybeCalculateFingerprintForRuntimeVersionInfoObjectsWithoutExpoUpdatesAsync({ projectDir, graphqlClient, runtimeToPlatformsAndFingerprintInfoAndFingerprintSourceMapping, workflowsByPlatform, env, }) {
-    const runtimesToComputeFingerprintsFor = runtimeToPlatformsAndFingerprintInfoAndFingerprintSourceMapping.filter(infoGroup => !infoGroup.fingerprintHash);
+    const runtimesToComputeFingerprintsFor = runtimeToPlatformsAndFingerprintInfoAndFingerprintSourceMapping.filter(infoGroup => !infoGroup.expoUpdatesRuntimeFingerprintHash);
     const fingerprintOptionsByRuntimeAndPlatform = new Map();
     for (const infoGroup of runtimesToComputeFingerprintsFor) {
         for (const platform of infoGroup.platforms) {
@@ -584,15 +584,16 @@ async function maybeCalculateFingerprintForRuntimeVersionInfoObjectsWithoutExpoU
     });
     // These are runtimes whose fingerprint has already been computed and uploaded with EAS Update fingerprint runtime policy
     const runtimesWithPreviouslyComputedFingerprints = runtimeToPlatformsAndFingerprintInfoAndFingerprintSourceMapping
-        .filter((infoGroup) => !!infoGroup.fingerprintHash && !!infoGroup.fingerprintSource)
+        .filter((infoGroup) => !!infoGroup.expoUpdatesRuntimeFingerprintHash &&
+        !!infoGroup.expoUpdatesRuntimeFingerprintSource)
         .map(infoGroup => {
         const platform = infoGroup.platforms[0];
         return {
             ...infoGroup,
             fingerprintInfoGroup: {
                 [platform]: {
-                    fingerprintHash: infoGroup.fingerprintHash,
-                    fingerprintSource: infoGroup.fingerprintSource,
+                    fingerprintHash: infoGroup.expoUpdatesRuntimeFingerprintHash,
+                    fingerprintSource: infoGroup.expoUpdatesRuntimeFingerprintSource,
                 },
             },
         };

package/build/project/resolveRuntimeVersionAsync.d.ts

@@ -8,11 +8,11 @@ export declare function resolveRuntimeVersionUsingCLIAsync({ platform, workflow,
     cwd?: string;
 }): Promise<{
     runtimeVersion: string | null;
-    fingerprint: {
+    expoUpdatesRuntimeFingerprint: {
         fingerprintSources: object[];
         isDebugFingerprintSource: boolean;
     } | null;
-    fingerprintHash: string | null;
+    expoUpdatesRuntimeFingerprintHash: string | null;
 }>;
 export declare function resolveRuntimeVersionAsync({ exp, platform, workflow, projectDir, env, cwd, }: {
     exp: ExpoConfig;
@@ -23,9 +23,9 @@ export declare function resolveRuntimeVersionAsync({ exp, platform, workflow, pr
     cwd?: string;
 }): Promise<{
     runtimeVersion: string | null;
-    fingerprint: {
+    expoUpdatesRuntimeFingerprint: {
         fingerprintSources: object[];
         isDebugFingerprintSource: boolean;
     } | null;
-    fingerprintHash: string | null;
+    expoUpdatesRuntimeFingerprintHash: string | null;
 } | null>;

package/build/project/resolveRuntimeVersionAsync.js

@@ -16,13 +16,13 @@ async function resolveRuntimeVersionUsingCLIAsync({ platform, workflow, projectD
     log_1.default.debug(resolvedRuntimeVersionJSONResult);
     return {
         runtimeVersion: runtimeVersionResult.runtimeVersion ?? null,
-        fingerprint: runtimeVersionResult.fingerprintSources
+        expoUpdatesRuntimeFingerprint: runtimeVersionResult.fingerprintSources
             ? {
                 fingerprintSources: runtimeVersionResult.fingerprintSources,
                 isDebugFingerprintSource: useDebugFingerprintSource,
             }
             : null,
-        fingerprintHash: runtimeVersionResult.fingerprintSources
+        expoUpdatesRuntimeFingerprintHash: runtimeVersionResult.fingerprintSources
             ? runtimeVersionResult.runtimeVersion
             : null,
     };
@@ -34,8 +34,8 @@ async function resolveRuntimeVersionAsync({ exp, platform, workflow, projectDir,
         // than the versioned @expo/config-plugins dependency in the project)
         return {
             runtimeVersion: await config_plugins_1.Updates.getRuntimeVersionNullableAsync(projectDir, exp, platform),
-            fingerprint: null,
-            fingerprintHash: null,
+            expoUpdatesRuntimeFingerprint: null,
+            expoUpdatesRuntimeFingerprintHash: null,
         };
     }
     try {

package/build/submit/ios/AppProduce.js

@@ -3,10 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ensureAppStoreConnectAppExistsAsync = void 0;
 const tslib_1 = require("tslib");
 const apple_utils_1 = require("@expo/apple-utils");
-const chalk_1 = tslib_1.__importDefault(require("chalk"));
 const language_1 = require("./utils/language");
 const authenticate_1 = require("../../credentials/ios/appstore/authenticate");
 const ensureAppExists_1 = require("../../credentials/ios/appstore/ensureAppExists");
+const ensureTestFlightGroup_1 = require("../../credentials/ios/appstore/ensureTestFlightGroup");
 const log_1 = tslib_1.__importDefault(require("../../log"));
 const bundleIdentifier_1 = require("../../project/ios/bundleIdentifier");
 const prompts_1 = require("../../prompts");
@@ -48,31 +48,20 @@ async function createAppStoreConnectAppAsync(ctx, options) {
     else {
         log_1.default.warn(`Provisioning is not available for Apple User: ${userAuthCtx.appleId}, skipping bundle identifier check.`);
     }
-    let app = null;
+    const app = await (0, ensureAppExists_1.ensureAppExistsAsync)(userAuthCtx, {
+        name: appName,
+        language,
+        companyName,
+        bundleIdentifier: bundleId,
+        sku,
+    });
     try {
-        app = await (0, ensureAppExists_1.ensureAppExistsAsync)(userAuthCtx, {
-            name: appName,
-            language,
-            companyName,
-            bundleIdentifier: bundleId,
-            sku,
-        });
+        await (0, ensureTestFlightGroup_1.ensureTestFlightGroupExistsAsync)(app);
     }
     catch (error) {
-        if (
-        // Name is invalid
-        error.message.match(/App Name contains certain Unicode(.*)characters that are not permitted/) ||
-            // UnexpectedAppleResponse: An attribute value has invalid characters. - App Name contains certain Unicode symbols, emoticons, diacritics, special characters, or private use characters that are not permitted.
-            // Name is taken
-            error.message.match(/The App Name you entered is already being used/)
-        // UnexpectedAppleResponse: The provided entity includes an attribute with a value that has already been used on a different account. - The App Name you entered is already being used. If you have trademark rights to
-        // this name and would like it released for your use, submit a claim.
-        ) {
-            log_1.default.addNewLineIfNone();
-            log_1.default.warn(`Change the name in your app config, or use a custom name with the ${chalk_1.default.bold('--app-name')} flag`);
-            log_1.default.newLine();
-        }
-        throw error;
+        // This process is not critical to the app submission so we shouldn't let it fail the entire process.
+        log_1.default.error('Failed to create an internal TestFlight group. This can be done manually in the App Store Connect website.');
+        log_1.default.error(error);
     }
     return {
         ascAppIdentifier: app.id,

package/build/utils/fingerprintCli.d.ts

@@ -1,11 +1,12 @@
 import { Env, Workflow } from '@expo/eas-build-job';
 import { Fingerprint, FingerprintDiffItem } from './fingerprint';
 export type FingerprintOptions = {
-    workflow: Workflow;
+    workflow?: Workflow;
     platforms: string[];
     debug?: boolean;
     env: Env | undefined;
     cwd?: string;
+    ignorePaths?: string[];
 };
 export declare function diffFingerprint(projectDir: string, fingerprint1: Fingerprint, fingerprint2: Fingerprint): FingerprintDiffItem[] | null;
 export declare function createFingerprintAsync(projectDir: string, options: FingerprintOptions): Promise<(Fingerprint & {

package/build/utils/fingerprintCli.js

@@ -52,12 +52,20 @@ exports.createFingerprintAsync = createFingerprintAsync;
 async function createFingerprintWithoutLoggingAsync(projectDir, fingerprintPath, options) {
     const Fingerprint = require(fingerprintPath);
     const fingerprintOptions = {};
+    const ignorePaths = [];
+    if (options.workflow === eas_build_job_1.Workflow.MANAGED) {
+        ignorePaths.push('android/**/*');
+        ignorePaths.push('ios/**/*');
+    }
+    if (options.ignorePaths) {
+        ignorePaths.push(...options.ignorePaths);
+    }
+    if (ignorePaths.length > 0) {
+        fingerprintOptions.ignorePaths = ignorePaths;
+    }
     if (options.platforms) {
         fingerprintOptions.platforms = [...options.platforms];
     }
-    if (options.workflow === eas_build_job_1.Workflow.MANAGED) {
-        fingerprintOptions.ignorePaths = ['android/**/*', 'ios/**/*'];
-    }
     if (options.debug) {
         fingerprintOptions.debug = true;
     }

package/build/worker/upload.js

@@ -8,6 +8,7 @@ const mime_1 = tslib_1.__importDefault(require("mime"));
 const minizlib_1 = require("minizlib");
 const node_fetch_1 = tslib_1.__importStar(require("node-fetch"));
 const node_fs_1 = tslib_1.__importStar(require("node:fs"));
+const promises_1 = require("node:fs/promises");
 const node_path_1 = tslib_1.__importDefault(require("node:path"));
 const promise_retry_1 = tslib_1.__importDefault(require("promise-retry"));
 const MAX_RETRIES = 4;
@@ -32,6 +33,21 @@ const isCompressible = (contentType, size) => {
         return true;
     }
 };
+const getContentTypeAsync = async (filePath) => {
+    let contentType = mime_1.default.getType(node_path_1.default.basename(filePath));
+    if (!contentType) {
+        const fileContent = await (0, promises_1.readFile)(filePath, 'utf-8');
+        try {
+            // check if file is valid JSON without an extension, e.g. for the apple app site association file
+            const parsedData = JSON.parse(fileContent);
+            if (parsedData) {
+                contentType = 'application/json';
+            }
+        }
+        catch { }
+    }
+    return contentType;
+};
 let sharedAgent;
 const getAgent = () => {
     if (sharedAgent) {
@@ -52,11 +68,11 @@ const getAgent = () => {
 };
 async function uploadAsync(params) {
     const { filePath, signal, compress, method = 'POST', url, headers: headersInit, ...requestInit } = params;
-    const stat = await node_fs_1.default.promises.stat(params.filePath);
+    const stat = await node_fs_1.default.promises.stat(filePath);
     if (stat.size > MAX_UPLOAD_SIZE) {
-        throw new Error(`Upload of "${params.filePath}" aborted: File size is greater than the upload limit (>500MB)`);
+        throw new Error(`Upload of "${filePath}" aborted: File size is greater than the upload limit (>500MB)`);
     }
-    const contentType = mime_1.default.getType(node_path_1.default.basename(params.filePath));
+    const contentType = await getContentTypeAsync(filePath);
     return await (0, promise_retry_1.default)(async (retry) => {
         const headers = new node_fetch_1.Headers(headersInit);
         if (contentType) {