eas-cli 14.4.1 → 14.6.0

package/build/credentials/ios/appstore/ensureTestFlightGroup.js

@@ -0,0 +1,158 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureTestFlightGroupExistsAsync = void 0;
+const tslib_1 = require("tslib");
+const apple_utils_1 = require("@expo/apple-utils");
+const ensureAppExists_1 = require("./ensureAppExists");
+const log_1 = tslib_1.__importDefault(require("../../../log"));
+const ora_1 = require("../../../ora");
+const prompts_1 = require("../../../prompts");
+// The name of the internal TestFlight group, this should probably never change.
+const AUTO_GROUP_NAME = 'Team (Expo)';
+/**
+ * Ensure a TestFlight internal group with access to all builds exists for the app and has all admin users invited to it.
+ * This allows users to instantly access their builds from TestFlight after it finishes processing.
+ */
+async function ensureTestFlightGroupExistsAsync(app) {
+    const group = await ensureInternalGroupAsync(app);
+    const users = await apple_utils_1.User.getAsync(app.context);
+    const admins = users.filter(user => user.attributes.roles?.includes(apple_utils_1.UserRole.ADMIN));
+    await addAllUsersToInternalGroupAsync(group, admins);
+}
+exports.ensureTestFlightGroupExistsAsync = ensureTestFlightGroupExistsAsync;
+async function ensureInternalGroupAsync(app) {
+    const groups = await app.getBetaGroupsAsync({
+        query: {
+            includes: ['betaTesters'],
+        },
+    });
+    let betaGroup = groups.find(group => group.attributes.name === AUTO_GROUP_NAME);
+    if (!betaGroup) {
+        const spinner = (0, ora_1.ora)().start('Creating TestFlight group...');
+        try {
+            // Apple throw an error if you create the group too quickly after creating the app. We'll retry a few times.
+            await pollRetryAsync(async () => {
+                betaGroup = await app.createBetaGroupAsync({
+                    name: AUTO_GROUP_NAME,
+                    publicLinkEnabled: false,
+                    publicLinkLimitEnabled: false,
+                    isInternalGroup: true,
+                    // Automatically add latest builds to the group without needing to run the command.
+                    hasAccessToAllBuilds: true,
+                });
+            }, {
+                shouldRetry(error) {
+                    if ((0, ensureAppExists_1.isAppleError)(error)) {
+                        spinner.text = `TestFlight not ready, retrying in 25 seconds...`;
+                        return error.data.errors.some(error => error.code === 'ENTITY_ERROR.RELATIONSHIP.INVALID');
+                    }
+                    return false;
+                },
+            });
+            spinner.succeed(`TestFlight group created: ${AUTO_GROUP_NAME}`);
+        }
+        catch (error) {
+            spinner.fail('Failed to create TestFlight group...');
+            throw error;
+        }
+    }
+    if (!betaGroup) {
+        throw new Error('Failed to create internal TestFlight group');
+    }
+    // `hasAccessToAllBuilds` is a newer feature that allows the group to automatically have access to all builds. This cannot be patched so we need to recreate the group.
+    if (!betaGroup.attributes.hasAccessToAllBuilds) {
+        if (await (0, prompts_1.confirmAsync)({
+            message: 'Regenerate internal TestFlight group to allow automatic access to all builds?',
+        })) {
+            await apple_utils_1.BetaGroup.deleteAsync(app.context, { id: betaGroup.id });
+            return await ensureInternalGroupAsync(app);
+        }
+    }
+    return betaGroup;
+}
+async function addAllUsersToInternalGroupAsync(group, users) {
+    let emails = users
+        .filter(user => user.attributes.email)
+        .map(user => ({
+        email: user.attributes.email,
+        firstName: user.attributes.firstName ?? '',
+        lastName: user.attributes.lastName ?? '',
+    }));
+    const { betaTesters } = group.attributes;
+    const existingEmails = betaTesters?.map(tester => tester.attributes.email).filter(Boolean) ?? [];
+    // Filter out existing beta testers.
+    if (betaTesters) {
+        emails = emails.filter(user => !existingEmails.find(existingEmail => existingEmail === user.email));
+    }
+    // No new users to add to the internal group.
+    if (!emails.length) {
+        // No need to log which users are here on subsequent runs as devs already know the drill at this point.
+        log_1.default.debug(`All current admins are already added to the group: ${group.attributes.name}`);
+        return;
+    }
+    log_1.default.debug(`Adding ${emails.length} users to internal group: ${group.attributes.name}`);
+    log_1.default.debug(`Users: ${emails.map(user => user.email).join(', ')}`);
+    const data = await group.createBulkBetaTesterAssignmentsAsync(emails);
+    const success = data.attributes.betaTesters.every(tester => {
+        if (tester.assignmentResult === 'FAILED') {
+            if (tester.errors && Array.isArray(tester.errors) && tester.errors.length) {
+                if (tester.errors.length === 1 &&
+                    tester.errors[0].key === 'Halliday.tester.already.exists') {
+                    return true;
+                }
+                for (const error of tester.errors) {
+                    log_1.default.error(`Error adding user ${tester.email} to TestFlight group "${group.attributes.name}": ${error.key}`);
+                }
+            }
+            return false;
+        }
+        if (tester.assignmentResult === 'NOT_QUALIFIED_FOR_INTERNAL_GROUP') {
+            return false;
+        }
+        return true;
+    });
+    if (!success) {
+        const groupUrl = await getTestFlightGroupUrlAsync(group);
+        log_1.default.error(`Unable to add all admins to TestFlight group "${group.attributes.name}". You can add them manually in App Store Connect. ${groupUrl ?? ''}`);
+    }
+    else {
+        log_1.default.log(`TestFlight access enabled for: ` +
+            data.attributes.betaTesters
+                .map(tester => tester.email)
+                .filter(Boolean)
+                .join(', '));
+        // TODO: When we have more TestFlight functionality, we can link to it from here.
+    }
+}
+async function getTestFlightGroupUrlAsync(group) {
+    if (group.context.providerId) {
+        try {
+            const session = await apple_utils_1.Session.getSessionForProviderIdAsync(group.context.providerId);
+            return `https://appstoreconnect.apple.com/teams/${session.provider.publicProviderId}/apps/6741088859/testflight/groups/${group.id}`;
+        }
+        catch (error) {
+            // Avoid crashing if we can't get the session.
+            log_1.default.debug('Failed to get session for provider ID', error);
+        }
+    }
+    return null;
+}
+async function pollRetryAsync(fn, { shouldRetry, retries = 10, 
+// 25 seconds was the minium interval I calculated when measuring against 5 second intervals.
+interval = 25000, } = {}) {
+    let lastError = null;
+    for (let i = 0; i < retries; i++) {
+        try {
+            return await fn();
+        }
+        catch (error) {
+            if (shouldRetry && !shouldRetry(error)) {
+                throw error;
+            }
+            lastError = error;
+            await new Promise(resolve => setTimeout(resolve, interval));
+        }
+    }
+    // eslint-disable-next-line @typescript-eslint/no-throw-literal
+    throw lastError;
+}

package/build/credentials/ios/appstore/provisioningProfile.js

@@ -20,6 +20,7 @@ function resolveProfileType(applePlatform, profileClass, isEnterprise) {
             return resolveProfileTypeIos(profileClass, isEnterprise);
         case constants_1.ApplePlatform.TV_OS:
             return resolveProfileTypeAppleTv(profileClass, isEnterprise);
+        case constants_1.ApplePlatform.VISION_OS:
         case constants_1.ApplePlatform.MAC_OS:
             throw new Error(`${applePlatform} profiles are not supported`);
     }

package/build/credentials/ios/appstore/resolveCredentials.js

@@ -162,13 +162,18 @@ async function promptUsernameAsync() {
     // Get the email address that was last used and set it as
     // the default value for quicker authentication.
     const lastAppleId = await getCachedUsernameAsync();
-    const { username } = await (0, prompts_1.promptAsync)({
+    let { username } = await (0, prompts_1.promptAsync)({
         type: 'text',
         name: 'username',
         message: `Apple ID:`,
         validate: (val) => val !== '',
         initial: lastAppleId ?? undefined,
     });
+    // https://github.com/expo/eas-cli/issues/2254
+    // user got an invalid unprintable character in their username, which was saved to cache and used to prefill the prompt
+    // which made them accept the prefilled value not knowing it contains the character and fail to log in
+    // this replace makes sure no such characters are used or cached
+    username = username.replace(/[\x00-\x1F]/gi, '');
     if (username && username !== lastAppleId) {
         await cacheUsernameAsync(username);
     }