@donotuse/eas-cli 18.5.0-rc.1

package/build/credentials/ios/actions/DeviceUtils.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.chooseDevicesAsync = chooseDevicesAsync;
+exports.formatDeviceLabel = formatDeviceLabel;
+const prompts_1 = require("../.././../prompts");
+const AppleDevice_1 = require("../../../graphql/types/credentials/AppleDevice");
+async function chooseDevicesAsync(allDevices, preselectedDeviceIdentifiers = []) {
+    const preselectedDeviceIdentifierSet = new Set(preselectedDeviceIdentifiers);
+    const isSelected = (device) => preselectedDeviceIdentifierSet.size === 0 ||
+        preselectedDeviceIdentifierSet.has(device.identifier);
+    const { devices } = await (0, prompts_1.promptAsync)({
+        type: 'multiselect',
+        name: 'devices',
+        selectionFormat: '<num> devices selected',
+        message: 'Select devices for the ad hoc build:',
+        hint: '- Space to select. Return to submit',
+        choices: allDevices.map(device => ({
+            value: device,
+            title: formatDeviceLabel(device),
+            selected: isSelected(device),
+        })),
+        instructions: false,
+        min: 1,
+    });
+    return devices;
+}
+function formatDeviceLabel(device) {
+    const deviceDetails = formatDeviceDetails(device);
+    return `${device.identifier}${deviceDetails !== '' ? ` ${deviceDetails}` : ''}${device.name ? ` (${device.name})` : ''}${device.createdAt ? ` (created at: ${device.createdAt})` : ''}`;
+}
+function formatDeviceDetails(device) {
+    let details = '';
+    if (device.deviceClass) {
+        details += AppleDevice_1.APPLE_DEVICE_CLASS_LABELS[device.deviceClass];
+    }
+    if (device.model) {
+        details += details === '' ? device.model : ` ${device.model}`;
+    }
+    return details === '' ? details : `(${details})`;
+}

package/build/credentials/ios/actions/DistributionCertificateUtils.d.ts

@@ -0,0 +1,14 @@
+import { AccountFragment, AppleDistributionCertificateFragment } from '../../../graphql/generated';
+import { CredentialsContext } from '../../context';
+import { AppLookupParams } from '../api/graphql/types/AppLookupParams';
+import { DistributionCertificate } from '../appstore/Credentials.types';
+export declare function formatDistributionCertificate(distributionCertificate: AppleDistributionCertificateFragment, validSerialNumbers?: string[]): string;
+/**
+ * select a distribution certificate from an account (validity status shown on a best effort basis)
+ * */
+export declare function selectDistributionCertificateWithDependenciesAsync(ctx: CredentialsContext, account: AccountFragment): Promise<AppleDistributionCertificateFragment | null>;
+/**
+ * select a distribution certificate from a valid set (curated on a best effort basis)
+ * */
+export declare function selectValidDistributionCertificateAsync(ctx: CredentialsContext, appLookupParams: AppLookupParams): Promise<AppleDistributionCertificateFragment | null>;
+export declare function provideOrGenerateDistributionCertificateAsync(ctx: CredentialsContext): Promise<DistributionCertificate>;

package/build/credentials/ios/actions/DistributionCertificateUtils.js

@@ -0,0 +1,192 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatDistributionCertificate = formatDistributionCertificate;
+exports.selectDistributionCertificateWithDependenciesAsync = selectDistributionCertificateWithDependenciesAsync;
+exports.selectValidDistributionCertificateAsync = selectValidDistributionCertificateAsync;
+exports.provideOrGenerateDistributionCertificateAsync = provideOrGenerateDistributionCertificateAsync;
+const tslib_1 = require("tslib");
+const assert_1 = tslib_1.__importDefault(require("assert"));
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const dateformat_1 = tslib_1.__importDefault(require("dateformat"));
+const AppleTeamFormatting_1 = require("./AppleTeamFormatting");
+const log_1 = tslib_1.__importStar(require("../../../log"));
+const prompts_1 = require("../../../prompts");
+const date_1 = require("../../../utils/date");
+const promptForCredentials_1 = require("../../utils/promptForCredentials");
+const CredentialsUtils_1 = require("../appstore/CredentialsUtils");
+const distributionCertificate_1 = require("../appstore/distributionCertificate");
+const credentials_1 = require("../credentials");
+const validateDistributionCertificate_1 = require("../validators/validateDistributionCertificate");
+function formatDistributionCertificate(distributionCertificate, validSerialNumbers) {
+    const { serialNumber, developerPortalIdentifier, appleTeam, validityNotBefore, validityNotAfter, updatedAt, } = distributionCertificate;
+    let line = '';
+    if (developerPortalIdentifier) {
+        line += `Cert ID: ${developerPortalIdentifier}`;
+    }
+    line += `${line === '' ? '' : ', '}Serial number: ${serialNumber}${appleTeam ? `, ${(0, AppleTeamFormatting_1.formatAppleTeam)(appleTeam)}` : ''}`;
+    line += chalk_1.default.gray(`\n    Created: ${(0, date_1.fromNow)(new Date(validityNotBefore))} ago, Updated: ${(0, date_1.fromNow)(new Date(updatedAt))} ago,`);
+    line += chalk_1.default.gray(`\n    Expires: ${(0, dateformat_1.default)(validityNotAfter, 'expiresHeaderFormat')}`);
+    const apps = distributionCertificate.iosAppBuildCredentialsList.map(buildCredentials => buildCredentials.iosAppCredentials.app);
+    if (apps.length) {
+        // iosAppBuildCredentialsList is capped at 20 on www
+        const appFullNames = apps
+            .map(app => app.fullName)
+            .slice(0, 19)
+            .join(',');
+        const andMaybeMore = apps.length > 19 ? ' (and more)' : '';
+        line += chalk_1.default.gray(`\n    📲 Used by: ${appFullNames}${andMaybeMore}`);
+    }
+    if (validSerialNumbers?.includes(serialNumber)) {
+        line += chalk_1.default.gray("\n    ✅ Currently valid on Apple's servers.");
+    }
+    else {
+        line += '';
+    }
+    return line;
+}
+async function selectDistributionCertificateAsync(distCerts, validDistributionCertificates) {
+    const validDistCertSerialNumbers = validDistributionCertificates?.map(distCert => distCert.serialNumber);
+    const { chosenDistCert } = await (0, prompts_1.promptAsync)({
+        type: 'select',
+        name: 'chosenDistCert',
+        message: 'Select certificate from the list.',
+        choices: distCerts.map(distCert => ({
+            title: formatDistributionCertificate(distCert, validDistCertSerialNumbers),
+            value: distCert,
+        })),
+    });
+    return chosenDistCert;
+}
+/**
+ * select a distribution certificate from an account (validity status shown on a best effort basis)
+ * */
+async function selectDistributionCertificateWithDependenciesAsync(ctx, account) {
+    const distCertsForAccount = await ctx.ios.getDistributionCertificatesForAccountAsync(ctx.graphqlClient, account);
+    if (distCertsForAccount.length === 0) {
+        log_1.default.warn(`There are no Distribution Certificates available in your EAS account.`);
+        return null;
+    }
+    if (!ctx.appStore.authCtx) {
+        return await selectDistributionCertificateAsync(distCertsForAccount);
+    }
+    // get valid certs on the developer portal
+    const certInfoFromApple = await ctx.appStore.listDistributionCertificatesAsync();
+    const validDistCerts = (0, CredentialsUtils_1.filterRevokedDistributionCertsFromEasServers)(distCertsForAccount, certInfoFromApple);
+    return await selectDistributionCertificateAsync(distCertsForAccount, validDistCerts);
+}
+/**
+ * select a distribution certificate from a valid set (curated on a best effort basis)
+ * */
+async function selectValidDistributionCertificateAsync(ctx, appLookupParams) {
+    const distCertsForAccount = await ctx.ios.getDistributionCertificatesForAccountAsync(ctx.graphqlClient, appLookupParams.account);
+    if (distCertsForAccount.length === 0) {
+        log_1.default.warn(`There are no Distribution Certificates available in your EAS account.`);
+        return null;
+    }
+    if (!ctx.appStore.authCtx) {
+        return await selectDistributionCertificateAsync(distCertsForAccount);
+    }
+    // filter by apple team
+    (0, assert_1.default)(ctx.appStore.authCtx, 'authentication to the Apple App Store is required');
+    const appleTeamIdentifier = ctx.appStore.authCtx.team.id;
+    const distCertsForAppleTeam = distCertsForAccount.filter(distCert => {
+        return !distCert.appleTeam || distCert.appleTeam.appleTeamIdentifier === appleTeamIdentifier;
+    });
+    // filter by valid certs on the developer portal
+    const certInfoFromApple = await ctx.appStore.listDistributionCertificatesAsync();
+    const validDistCerts = (0, CredentialsUtils_1.filterRevokedDistributionCertsFromEasServers)(distCertsForAppleTeam, certInfoFromApple);
+    log_1.default.log(`${validDistCerts.length}/${distCertsForAccount.length} Distribution Certificates are currently valid for Apple Team ${ctx.appStore.authCtx?.team.id}.`);
+    return await selectDistributionCertificateAsync(validDistCerts);
+}
+const APPLE_DIST_CERTS_TOO_MANY_GENERATED_ERROR = `
+You can have only ${chalk_1.default.underline('three')} Apple Distribution Certificates generated on your Apple Developer account.
+Revoke the old ones or reuse existing from your other apps.
+Remember that Apple Distribution Certificates are not application specific!
+`;
+async function provideOrGenerateDistributionCertificateAsync(ctx) {
+    if (!ctx.nonInteractive && !ctx.autoAcceptCredentialReuse) {
+        const userProvided = await promptForDistCertAsync(ctx);
+        if (userProvided) {
+            if (!ctx.appStore.authCtx) {
+                log_1.default.warn('Unable to validate distribution certificate, you are not authenticated with Apple.');
+                return userProvided;
+            }
+            else {
+                const isValid = await (0, validateDistributionCertificate_1.validateDistributionCertificateAsync)(ctx, userProvided);
+                if (!isValid) {
+                    log_1.default.warn("Provided Distribution Certificate is no longer valid on Apple's server");
+                }
+                return isValid ? userProvided : await provideOrGenerateDistributionCertificateAsync(ctx);
+            }
+        }
+    }
+    return await generateDistributionCertificateAsync(ctx);
+}
+async function promptForDistCertAsync(ctx) {
+    let initialValues = {};
+    if (ctx.appStore.authCtx) {
+        initialValues = {
+            teamId: ctx.appStore.authCtx.team.id,
+        };
+    }
+    const userProvided = await (0, promptForCredentials_1.askForUserProvidedAsync)(credentials_1.distributionCertificateSchema, initialValues);
+    if (!userProvided) {
+        return null;
+    }
+    if (ctx.appStore.authCtx && userProvided.teamId === initialValues.teamId) {
+        return {
+            ...userProvided,
+            teamName: ctx.appStore.authCtx.team.name,
+        };
+    }
+    return userProvided;
+}
+async function generateDistributionCertificateAsync(ctx) {
+    await ctx.appStore.ensureAuthenticatedAsync();
+    try {
+        return await ctx.appStore.createDistributionCertificateAsync();
+    }
+    catch (e) {
+        if (e instanceof distributionCertificate_1.AppleTooManyCertsError) {
+            const distCerts = await ctx.appStore.listDistributionCertificatesAsync();
+            log_1.default.warn('Maximum number of Distribution Certificates generated on Apple Developer Portal.');
+            log_1.default.warn(APPLE_DIST_CERTS_TOO_MANY_GENERATED_ERROR);
+            if (ctx.nonInteractive) {
+                throw new Error("Start the CLI without the '--non-interactive' flag to revoke existing certificates.");
+            }
+            log_1.default.log(chalk_1.default.grey(`✅  Distribution Certificates can be revoked with no side effects for App Store builds.`));
+            log_1.default.log((0, log_1.learnMore)('https://docs.expo.dev/app-signing/app-credentials/#summary'));
+            log_1.default.newLine();
+            const { distCertsToRevoke } = await (0, prompts_1.promptAsync)({
+                type: 'multiselect',
+                name: 'distCertsToRevoke',
+                message: 'Select certificates to revoke.',
+                // @ts-expect-error property missing from `@types/prompts`
+                optionsPerPage: 20,
+                choices: distCerts.map(distCert => ({
+                    value: distCert,
+                    title: formatDistributionCertificateFromApple(distCert),
+                })),
+            });
+            if (distCertsToRevoke.length > 0) {
+                const ids = distCertsToRevoke.map(({ id }) => id);
+                await ctx.appStore.revokeDistributionCertificateAsync(ids);
+            }
+        }
+        else {
+            throw e;
+        }
+    }
+    return await generateDistributionCertificateAsync(ctx);
+}
+function formatDistributionCertificateFromApple(appleInfo) {
+    const { name, status, id, expires, created, ownerName, serialNumber } = appleInfo;
+    const expiresDate = new Date(expires * 1000).toDateString();
+    const createdDate = new Date(created * 1000).toDateString();
+    return [
+        `🍏 ${chalk_1.default.bold(name)} (${status})`,
+        `${chalk_1.default.bold('ID:')} ${id} ${chalk_1.default.bold('Serial Number:')} ${serialNumber}`,
+        `${chalk_1.default.bold('Apple Team:')} ${appleInfo.ownerId} (${ownerName})`,
+        `${chalk_1.default.bold('Expires:')} ${expiresDate} ${chalk_1.default.bold('Created:')} ${createdDate}`,
+    ].join('\n\t');
+}

package/build/credentials/ios/actions/ProvisioningProfileUtils.d.ts

@@ -0,0 +1,5 @@
+import { CredentialsContext } from '../../context';
+import { DistributionCertificate, ProvisioningProfile, ProvisioningProfileStoreInfo } from '../appstore/Credentials.types';
+import { Target } from '../types';
+export declare function formatProvisioningProfileFromApple(appleInfo: ProvisioningProfileStoreInfo): string;
+export declare function generateProvisioningProfileAsync(ctx: CredentialsContext, target: Target, bundleIdentifier: string, distCert: DistributionCertificate): Promise<ProvisioningProfile>;

package/build/credentials/ios/actions/ProvisioningProfileUtils.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatProvisioningProfileFromApple = formatProvisioningProfileFromApple;
+exports.generateProvisioningProfileAsync = generateProvisioningProfileAsync;
+const tslib_1 = require("tslib");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const target_1 = require("../../../project/ios/target");
+function formatProvisioningProfileFromApple(appleInfo) {
+    const { expires, provisioningProfileId } = appleInfo;
+    const id = provisioningProfileId ?? '-----';
+    const name = appleInfo.name ?? '-----';
+    const expiryString = expires ? new Date(expires * 1000).toDateString() : 'unknown';
+    const details = chalk_1.default.green(`\n    Name: ${name}\n    Expiry: ${expiryString}`);
+    return `Provisioning Profile - ID: ${id}${details}`;
+}
+async function generateProvisioningProfileAsync(ctx, target, bundleIdentifier, distCert) {
+    const appleAuthCtx = await ctx.appStore.ensureAuthenticatedAsync();
+    const type = appleAuthCtx.team.inHouse ? 'Enterprise ' : 'AppStore';
+    const profileName = `*[expo] ${bundleIdentifier} ${type} ${new Date().toISOString()}`; // Apple drops [ if its the first char (!!)
+    const applePlatform = (0, target_1.getApplePlatformFromTarget)(target);
+    return await ctx.appStore.createProvisioningProfileAsync(bundleIdentifier, distCert, profileName, applePlatform);
+}

package/build/credentials/ios/actions/PushKeyUtils.d.ts

@@ -0,0 +1,11 @@
+import { AccountFragment, ApplePushKeyFragment } from '../../../graphql/generated';
+import { CredentialsContext } from '../../context';
+import { PushKey } from '../appstore/Credentials.types';
+export declare function provideOrGeneratePushKeyAsync(ctx: CredentialsContext): Promise<PushKey>;
+/**
+ * select a push key from an account (validity status shown on a best effort basis)
+ * */
+export declare function selectPushKeyAsync(ctx: CredentialsContext, account: AccountFragment): Promise<ApplePushKeyFragment | null>;
+export declare function getValidAndTrackedPushKeysOnEasServersAsync(ctx: CredentialsContext, pushKeysForAccount: ApplePushKeyFragment[]): Promise<ApplePushKeyFragment[]>;
+export declare function sortPushKeys(pushKeys: ApplePushKeyFragment[], validPushKeys?: ApplePushKeyFragment[]): ApplePushKeyFragment[];
+export declare function formatPushKey(pushKey: ApplePushKeyFragment, validPushKeyIdentifiers?: string[]): string;

package/build/credentials/ios/actions/PushKeyUtils.js

@@ -0,0 +1,175 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.provideOrGeneratePushKeyAsync = provideOrGeneratePushKeyAsync;
+exports.selectPushKeyAsync = selectPushKeyAsync;
+exports.getValidAndTrackedPushKeysOnEasServersAsync = getValidAndTrackedPushKeysOnEasServersAsync;
+exports.sortPushKeys = sortPushKeys;
+exports.formatPushKey = formatPushKey;
+const tslib_1 = require("tslib");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const AppleTeamFormatting_1 = require("./AppleTeamFormatting");
+const log_1 = tslib_1.__importStar(require("../../../log"));
+const prompts_1 = require("../../../prompts");
+const date_1 = require("../../../utils/date");
+const promptForCredentials_1 = require("../../utils/promptForCredentials");
+const CredentialsUtils_1 = require("../appstore/CredentialsUtils");
+const pushKey_1 = require("../appstore/pushKey");
+const credentials_1 = require("../credentials");
+const validatePushKey_1 = require("../validators/validatePushKey");
+async function provideOrGeneratePushKeyAsync(ctx) {
+    if (!ctx.nonInteractive && !ctx.autoAcceptCredentialReuse) {
+        const userProvided = await promptForPushKeyAsync(ctx);
+        if (userProvided) {
+            if (!ctx.appStore.authCtx) {
+                log_1.default.warn('Unable to validate push key, you are not authenticated with Apple.');
+                return userProvided;
+            }
+            else {
+                const isValidAndTracked = await (0, validatePushKey_1.isPushKeyValidAndTrackedAsync)(ctx, userProvided);
+                if (isValidAndTracked) {
+                    return userProvided;
+                }
+                // user could've just input the id wrong, and the p8 could still be valid
+                const useUserProvided = await (0, prompts_1.confirmAsync)({
+                    message: `Push Key with ID ${userProvided.apnsKeyId} could not be found on Apple's servers. Proceed anyway?`,
+                });
+                if (useUserProvided) {
+                    return userProvided;
+                }
+                return await provideOrGeneratePushKeyAsync(ctx);
+            }
+        }
+    }
+    return await generatePushKeyAsync(ctx);
+}
+async function promptForPushKeyAsync(ctx) {
+    let initialValues = {};
+    if (ctx.appStore.authCtx) {
+        initialValues = {
+            teamId: ctx.appStore.authCtx.team.id,
+        };
+    }
+    const userProvided = await (0, promptForCredentials_1.askForUserProvidedAsync)(credentials_1.pushKeySchema, initialValues);
+    if (!userProvided) {
+        return null;
+    }
+    if (ctx.appStore.authCtx && userProvided.teamId === initialValues.teamId) {
+        return {
+            ...userProvided,
+            teamName: ctx.appStore.authCtx.team.name,
+        };
+    }
+    return userProvided;
+}
+async function generatePushKeyAsync(ctx) {
+    await ctx.appStore.ensureAuthenticatedAsync();
+    try {
+        return await ctx.appStore.createPushKeyAsync();
+    }
+    catch (e) {
+        if (e.message === pushKey_1.APPLE_KEYS_TOO_MANY_GENERATED_ERROR) {
+            const pushKeys = await ctx.appStore.listPushKeysAsync();
+            log_1.default.warn('Maximum number of Push Notifications Keys generated on Apple Developer Portal.');
+            log_1.default.warn(pushKey_1.APPLE_KEYS_TOO_MANY_GENERATED_ERROR);
+            if (ctx.nonInteractive) {
+                throw new Error("Start the CLI without the '--non-interactive' flag to revoke existing push notification keys.");
+            }
+            log_1.default.log(chalk_1.default.grey(`⚠️  Revoking a Push Key will affect other apps that rely on it`));
+            log_1.default.log((0, log_1.learnMore)('https://docs.expo.dev/app-signing/app-credentials/#push-notification-keys'));
+            log_1.default.log();
+            const { pushKeysToRevoke } = await (0, prompts_1.promptAsync)({
+                type: 'multiselect',
+                name: 'pushKeysToRevoke',
+                message: 'Select Push Notifications Key to revoke.',
+                // @ts-expect-error property missing from `@types/prompts`
+                optionsPerPage: 20,
+                choices: pushKeys.map(pushKey => ({
+                    value: pushKey,
+                    title: formatPushKeyFromApple(pushKey),
+                })),
+            });
+            if (pushKeysToRevoke.length > 0) {
+                const ids = pushKeysToRevoke.map(({ id }) => id);
+                await ctx.appStore.revokePushKeyAsync(ids);
+            }
+        }
+        else {
+            throw e;
+        }
+    }
+    return await generatePushKeyAsync(ctx);
+}
+function formatPushKeyFromApple(pushKey) {
+    const { name, id } = pushKey;
+    const keyIdText = id ? ` - Key ID: ${id}` : ``;
+    return `${name}${keyIdText}`;
+}
+/**
+ * select a push key from an account (validity status shown on a best effort basis)
+ * */
+async function selectPushKeyAsync(ctx, account) {
+    const pushKeysForAccount = await ctx.ios.getPushKeysForAccountAsync(ctx.graphqlClient, account);
+    if (pushKeysForAccount.length === 0) {
+        log_1.default.warn(`There are no Push Keys available in your EAS account.`);
+        return null;
+    }
+    if (!ctx.appStore.authCtx) {
+        return await selectPushKeysAsync(pushKeysForAccount);
+    }
+    const validPushKeys = await getValidAndTrackedPushKeysOnEasServersAsync(ctx, pushKeysForAccount);
+    return await selectPushKeysAsync(pushKeysForAccount, validPushKeys);
+}
+async function getValidAndTrackedPushKeysOnEasServersAsync(ctx, pushKeysForAccount) {
+    const pushInfoFromApple = await ctx.appStore.listPushKeysAsync();
+    return await (0, CredentialsUtils_1.filterRevokedAndUntrackedPushKeysFromEasServersAsync)(pushKeysForAccount, pushInfoFromApple);
+}
+async function selectPushKeysAsync(pushKeys, validPushKeys) {
+    const validPushKeyIdentifiers = validPushKeys?.map(pushKey => pushKey.keyIdentifier);
+    const sortedPushKeys = sortPushKeys(pushKeys, validPushKeys);
+    const { chosenPushKey } = await (0, prompts_1.promptAsync)({
+        type: 'select',
+        name: 'chosenPushKey',
+        message: 'Select a push key from the list.',
+        choices: sortedPushKeys.map(pushKey => ({
+            title: formatPushKey(pushKey, validPushKeyIdentifiers),
+            value: pushKey,
+        })),
+    });
+    return chosenPushKey;
+}
+function sortPushKeys(pushKeys, validPushKeys) {
+    const validPushKeyIdentifiers = validPushKeys?.map(pushKey => pushKey.keyIdentifier);
+    return pushKeys.sort((pushKeyA, pushKeyB) => {
+        if (validPushKeyIdentifiers?.includes(pushKeyA.keyIdentifier)) {
+            return -1;
+        }
+        else if (validPushKeyIdentifiers?.includes(pushKeyB.keyIdentifier)) {
+            return 1;
+        }
+        return 0;
+    });
+}
+function formatPushKey(pushKey, validPushKeyIdentifiers) {
+    const { keyIdentifier, appleTeam, updatedAt } = pushKey;
+    let line = '';
+    line += `Push Key ID: ${pushKey.keyIdentifier}`;
+    line += ` ${appleTeam ? `, ${(0, AppleTeamFormatting_1.formatAppleTeam)(appleTeam)}` : ''}`;
+    line += chalk_1.default.gray(`\n    Updated: ${(0, date_1.fromNow)(new Date(updatedAt))} ago,`);
+    const apps = pushKey.iosAppCredentialsList.map(appCredentials => appCredentials.app);
+    if (apps.length) {
+        // iosAppCredentialsList is capped at 20 on www
+        const appFullNames = apps
+            .map(app => app.fullName)
+            .slice(0, 19)
+            .join(',');
+        const andMaybeMore = apps.length > 19 ? ' (and more)' : '';
+        line += chalk_1.default.gray(`\n    📲 Used by: ${appFullNames}${andMaybeMore}`);
+    }
+    if (validPushKeyIdentifiers?.includes(keyIdentifier)) {
+        line += chalk_1.default.gray("\n    ✅ Currently valid on Apple's servers.");
+    }
+    else {
+        line += '';
+    }
+    return line;
+}

package/build/credentials/ios/actions/RemoveAscApiKey.d.ts

@@ -0,0 +1,12 @@
+import { AccountFragment, AppStoreConnectApiKeyFragment } from '../../../graphql/generated';
+import { CredentialsContext } from '../../context';
+export declare class SelectAndRemoveAscApiKey {
+    private readonly account;
+    constructor(account: AccountFragment);
+    runAsync(ctx: CredentialsContext): Promise<void>;
+}
+export declare class RemoveAscApiKey {
+    private readonly ascApiKey;
+    constructor(ascApiKey: AppStoreConnectApiKeyFragment);
+    runAsync(ctx: CredentialsContext): Promise<void>;
+}

package/build/credentials/ios/actions/RemoveAscApiKey.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RemoveAscApiKey = exports.SelectAndRemoveAscApiKey = void 0;
+const tslib_1 = require("tslib");
+const AscApiKeyUtils_1 = require("./AscApiKeyUtils");
+const log_1 = tslib_1.__importDefault(require("../../../log"));
+const prompts_1 = require("../../../prompts");
+class SelectAndRemoveAscApiKey {
+    account;
+    constructor(account) {
+        this.account = account;
+    }
+    async runAsync(ctx) {
+        const selected = await (0, AscApiKeyUtils_1.selectAscApiKeysFromAccountAsync)(ctx, this.account);
+        if (selected) {
+            await new RemoveAscApiKey(selected).runAsync(ctx);
+            log_1.default.succeed('Removed App Store Connect API Key');
+            log_1.default.newLine();
+        }
+    }
+}
+exports.SelectAndRemoveAscApiKey = SelectAndRemoveAscApiKey;
+class RemoveAscApiKey {
+    ascApiKey;
+    constructor(ascApiKey) {
+        this.ascApiKey = ascApiKey;
+    }
+    async runAsync(ctx) {
+        if (ctx.nonInteractive) {
+            throw new Error(`Cannot remove App Store Connect API Keys in non-interactive mode.`);
+        }
+        // TODO(quin): add an extra edge on AppStoreConnectApiKey to find the apps using it
+        const confirm = await (0, prompts_1.confirmAsync)({
+            message: `Deleting this API Key may affect your projects that rely on it. Do you want to continue?`,
+        });
+        if (!confirm) {
+            log_1.default.log('Aborting');
+            return;
+        }
+        log_1.default.log('Removing API Key');
+        await ctx.ios.deleteAscApiKeyAsync(ctx.graphqlClient, this.ascApiKey.id);
+        let shouldRevoke = false;
+        if (!ctx.nonInteractive) {
+            shouldRevoke = await (0, prompts_1.confirmAsync)({
+                message: `Do you also want to revoke this API Key on the Apple Developer Portal?`,
+            });
+        }
+        else if (ctx.nonInteractive) {
+            log_1.default.log('Skipping API Key revocation on the Apple Developer Portal.');
+        }
+        if (shouldRevoke) {
+            await ctx.appStore.revokeAscApiKeyAsync(this.ascApiKey.keyIdentifier);
+        }
+    }
+}
+exports.RemoveAscApiKey = RemoveAscApiKey;

package/build/credentials/ios/actions/RemoveDistributionCertificate.d.ts

@@ -0,0 +1,14 @@
+import { AccountFragment, AppleDistributionCertificateFragment } from '../../../graphql/generated';
+import { CredentialsContext } from '../../context';
+export declare class SelectAndRemoveDistributionCertificate {
+    private readonly account;
+    constructor(account: AccountFragment);
+    runAsync(ctx: CredentialsContext): Promise<void>;
+}
+export declare class RemoveDistributionCertificate {
+    private readonly account;
+    private readonly distributionCertificate;
+    constructor(account: AccountFragment, distributionCertificate: AppleDistributionCertificateFragment);
+    runAsync(ctx: CredentialsContext): Promise<void>;
+    private removeInvalidProvisioningProfilesAsync;
+}

package/build/credentials/ios/actions/RemoveDistributionCertificate.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RemoveDistributionCertificate = exports.SelectAndRemoveDistributionCertificate = void 0;
+const tslib_1 = require("tslib");
+const DistributionCertificateUtils_1 = require("./DistributionCertificateUtils");
+const RemoveProvisioningProfile_1 = require("./RemoveProvisioningProfile");
+const log_1 = tslib_1.__importDefault(require("../../../log"));
+const prompts_1 = require("../../../prompts");
+class SelectAndRemoveDistributionCertificate {
+    account;
+    constructor(account) {
+        this.account = account;
+    }
+    async runAsync(ctx) {
+        const selected = await (0, DistributionCertificateUtils_1.selectDistributionCertificateWithDependenciesAsync)(ctx, this.account);
+        if (selected) {
+            await new RemoveDistributionCertificate(this.account, selected).runAsync(ctx);
+            log_1.default.succeed('Removed distribution certificate');
+            log_1.default.newLine();
+        }
+    }
+}
+exports.SelectAndRemoveDistributionCertificate = SelectAndRemoveDistributionCertificate;
+class RemoveDistributionCertificate {
+    account;
+    distributionCertificate;
+    constructor(account, distributionCertificate) {
+        this.account = account;
+        this.distributionCertificate = distributionCertificate;
+    }
+    async runAsync(ctx) {
+        const apps = this.distributionCertificate.iosAppBuildCredentialsList.map(buildCredentials => buildCredentials.iosAppCredentials.app);
+        if (apps.length !== 0) {
+            // iosAppBuildCredentialsList is capped at 20 on www
+            const appFullNames = apps
+                .map(app => app.fullName)
+                .slice(0, 19)
+                .join(',');
+            const andMaybeMore = apps.length > 19 ? ' (and more)' : '';
+            if (ctx.nonInteractive) {
+                throw new Error(`Certificate is currently used by ${appFullNames}${andMaybeMore} and cannot be deleted in non-interactive mode.`);
+            }
+            const confirm = await (0, prompts_1.confirmAsync)({
+                message: `You are removing certificate used by ${appFullNames}${andMaybeMore}. Do you want to continue?`,
+            });
+            if (!confirm) {
+                log_1.default.log('Aborting');
+                return;
+            }
+        }
+        log_1.default.log('Removing Distribution Certificate');
+        await ctx.ios.deleteDistributionCertificateAsync(ctx.graphqlClient, this.distributionCertificate.id);
+        if (this.distributionCertificate.developerPortalIdentifier) {
+            let shouldRevoke = false;
+            if (!ctx.nonInteractive) {
+                shouldRevoke = await (0, prompts_1.confirmAsync)({
+                    message: `Do you also want to revoke this Distribution Certificate on Apple Developer Portal?`,
+                });
+            }
+            else if (ctx.nonInteractive) {
+                log_1.default.log('Skipping certificate revocation on the Apple Developer Portal.');
+            }
+            if (shouldRevoke) {
+                await ctx.appStore.revokeDistributionCertificateAsync([
+                    this.distributionCertificate.developerPortalIdentifier,
+                ]);
+            }
+        }
+        await this.removeInvalidProvisioningProfilesAsync(ctx);
+    }
+    async removeInvalidProvisioningProfilesAsync(ctx) {
+        const buildCredentialsList = this.distributionCertificate.iosAppBuildCredentialsList;
+        const appsWithProfilesToRemove = [];
+        const profilesToRemove = [];
+        for (const buildCredentials of buildCredentialsList) {
+            const projectName = buildCredentials.iosAppCredentials.app.slug;
+            const { bundleIdentifier } = buildCredentials.iosAppCredentials.appleAppIdentifier;
+            const appLookupParams = { account: this.account, projectName, bundleIdentifier };
+            const maybeProvisioningProfile = buildCredentials.provisioningProfile;
+            if (maybeProvisioningProfile) {
+                appsWithProfilesToRemove.push(appLookupParams);
+                profilesToRemove.push(maybeProvisioningProfile);
+            }
+        }
+        await new RemoveProvisioningProfile_1.RemoveProvisioningProfiles(appsWithProfilesToRemove, profilesToRemove).runAsync(ctx);
+    }
+}
+exports.RemoveDistributionCertificate = RemoveDistributionCertificate;

package/build/credentials/ios/actions/RemoveProvisioningProfile.d.ts

@@ -0,0 +1,9 @@
+import { AppleProvisioningProfileIdentifiersFragment } from '../../../graphql/generated';
+import { CredentialsContext } from '../../context';
+import { AppLookupParams } from '../api/graphql/types/AppLookupParams';
+export declare class RemoveProvisioningProfiles {
+    private readonly apps;
+    private readonly provisioningProfiles;
+    constructor(apps: AppLookupParams[], provisioningProfiles: AppleProvisioningProfileIdentifiersFragment[]);
+    runAsync(ctx: CredentialsContext): Promise<void>;
+}