@donotuse/eas-cli 18.5.0-rc.1

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

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.APPLE_KEYS_TOO_MANY_GENERATED_ERROR = void 0;
+exports.listPushKeysAsync = listPushKeysAsync;
+exports.createPushKeyAsync = createPushKeyAsync;
+exports.revokePushKeyAsync = revokePushKeyAsync;
+const tslib_1 = require("tslib");
+const apple_utils_1 = require("@expo/apple-utils");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const dateformat_1 = tslib_1.__importDefault(require("dateformat"));
+const authenticate_1 = require("./authenticate");
+const log_1 = tslib_1.__importDefault(require("../../../log"));
+const ora_1 = require("../../../ora");
+const { MaxKeysCreatedError } = apple_utils_1.Keys;
+exports.APPLE_KEYS_TOO_MANY_GENERATED_ERROR = `
+You can have only ${chalk_1.default.underline('two')} Apple Keys generated on your Apple Developer account.
+Revoke the old ones or reuse existing from your other apps.
+Remember that Apple Keys are not application specific!
+`;
+/**
+ * List all existing push keys on Apple servers.
+ * **Does not support App Store Connect API (CI).**
+ */
+async function listPushKeysAsync(userAuthCtx) {
+    const spinner = (0, ora_1.ora)(`Fetching Apple push keys`).start();
+    try {
+        const context = (0, authenticate_1.getRequestContext)(userAuthCtx);
+        const keys = await apple_utils_1.Keys.getKeysAsync(context);
+        spinner.succeed(`Fetched Apple push keys`);
+        return keys;
+    }
+    catch (error) {
+        spinner.fail(`Failed to fetch Apple push keys`);
+        throw error;
+    }
+}
+/**
+ * Create a new push key on Apple servers.
+ * **Does not support App Store Connect API (CI).**
+ */
+async function createPushKeyAsync(userAuthCtx, name = `Expo Push Notifications Key ${(0, dateformat_1.default)('yyyymmddHHMMss')}`) {
+    const spinner = (0, ora_1.ora)(`Creating Apple push key`).start();
+    try {
+        const context = (0, authenticate_1.getRequestContext)(userAuthCtx);
+        const key = await apple_utils_1.Keys.createKeyAsync(context, { name, isApns: true });
+        const apnsKeyP8 = await apple_utils_1.Keys.downloadKeyAsync(context, { id: key.id });
+        spinner.succeed(`Created Apple push key`);
+        return {
+            apnsKeyId: key.id,
+            apnsKeyP8,
+            teamId: userAuthCtx.team.id,
+            teamName: userAuthCtx.team.name,
+        };
+    }
+    catch (err) {
+        spinner.fail('Failed to create Apple push key');
+        const resultString = err.rawDump?.resultString;
+        if (err instanceof MaxKeysCreatedError ||
+            resultString?.match(/maximum allowed number of Keys/)) {
+            throw new Error(exports.APPLE_KEYS_TOO_MANY_GENERATED_ERROR);
+        }
+        throw err;
+    }
+}
+/**
+ * Revoke an existing push key on Apple servers.
+ * **Does not support App Store Connect API (CI).**
+ */
+async function revokePushKeyAsync(userAuthCtx, ids) {
+    const name = `Apple push key${ids?.length === 1 ? '' : 's'}`;
+    const spinner = (0, ora_1.ora)(`Revoking ${name}`).start();
+    try {
+        const context = (0, authenticate_1.getRequestContext)(userAuthCtx);
+        await Promise.all(ids.map(id => apple_utils_1.Keys.revokeKeyAsync(context, { id })));
+        spinner.succeed(`Revoked ${name}`);
+    }
+    catch (error) {
+        log_1.default.error(error);
+        spinner.fail(`Failed to revoke ${name}`);
+        throw error;
+    }
+}

package/build/credentials/ios/appstore/resolveCredentials.d.ts

@@ -0,0 +1,19 @@
+import { Auth } from '@expo/apple-utils';
+import { AppleTeamType, Team } from './authenticateTypes';
+import { MinimalAscApiKey } from '../credentials';
+/**
+ * Get the username and possibly the password from the environment variables or the supplied options.
+ * Password is optional because it's only needed for authentication, but not for re-authentication.
+ *
+ * @param options
+ */
+export declare function resolveUserCredentialsAsync(options: Partial<Auth.UserCredentials>): Promise<Partial<Auth.UserCredentials>>;
+export declare function hasAscEnvVars(): boolean;
+export declare function resolveAscApiKeyAsync(ascApiKey?: MinimalAscApiKey): Promise<MinimalAscApiKey>;
+export declare function resolveAppleTeamAsync(options?: {
+    teamId?: string;
+    teamName?: string;
+    teamType?: AppleTeamType;
+}): Promise<Team>;
+export declare function promptPasswordAsync({ username, }: Pick<Auth.UserCredentials, 'username'>): Promise<string>;
+export declare function deletePasswordAsync({ username, }: Pick<Auth.UserCredentials, 'username'>): Promise<boolean>;

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

@@ -0,0 +1,256 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveUserCredentialsAsync = resolveUserCredentialsAsync;
+exports.hasAscEnvVars = hasAscEnvVars;
+exports.resolveAscApiKeyAsync = resolveAscApiKeyAsync;
+exports.resolveAppleTeamAsync = resolveAppleTeamAsync;
+exports.promptPasswordAsync = promptPasswordAsync;
+exports.deletePasswordAsync = deletePasswordAsync;
+const tslib_1 = require("tslib");
+const apple_utils_1 = require("@expo/apple-utils");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const fs = tslib_1.__importStar(require("fs-extra"));
+const wrap_ansi_1 = tslib_1.__importDefault(require("wrap-ansi"));
+const authenticateTypes_1 = require("./authenticateTypes");
+const Keychain = tslib_1.__importStar(require("./keychain"));
+const log_1 = tslib_1.__importStar(require("../../../log"));
+const prompts_1 = require("../../../prompts");
+/**
+ * Get the username and possibly the password from the environment variables or the supplied options.
+ * Password is optional because it's only needed for authentication, but not for re-authentication.
+ *
+ * @param options
+ */
+async function resolveUserCredentialsAsync(options) {
+    const credentials = getAppleIdFromEnvironmentOrOptions(options);
+    if (!credentials.username) {
+        credentials.username = await promptUsernameAsync();
+    }
+    return credentials;
+}
+function hasAscEnvVars() {
+    return (!!process.env.EXPO_ASC_API_KEY_PATH ||
+        !!process.env.EXPO_ASC_KEY_ID ||
+        !!process.env.EXPO_ASC_ISSUER_ID);
+}
+async function resolveAscApiKeyAsync(ascApiKey) {
+    const passedKeyP8 = await getAscKeyP8FromEnvironmentOrOptionsAsync(ascApiKey);
+    const passedKeyId = await getAscKeyIdFromEnvironmentOrOptionsAsync(ascApiKey);
+    const passedIssuerId = await getAscIssuerIdFromEnvironmentOrOptionsAsync(ascApiKey);
+    return {
+        keyP8: passedKeyP8,
+        keyId: passedKeyId,
+        issuerId: passedIssuerId,
+    };
+}
+async function getAscKeyP8FromEnvironmentOrOptionsAsync(ascApiKey) {
+    if (ascApiKey?.keyP8) {
+        return ascApiKey?.keyP8;
+    }
+    else if (process.env.EXPO_ASC_API_KEY_PATH) {
+        return await fs.readFile(process.env.EXPO_ASC_API_KEY_PATH, 'utf-8');
+    }
+    const { ascApiKeyPath } = await (0, prompts_1.promptAsync)({
+        type: 'text',
+        name: 'ascApiKeyPath',
+        message: `Path to ASC Api Key Path (.p8):`,
+        validate: (val) => val !== '',
+    });
+    return await fs.readFile(ascApiKeyPath, 'utf-8');
+}
+async function getAscKeyIdFromEnvironmentOrOptionsAsync(ascApiKey) {
+    if (ascApiKey?.keyId) {
+        return ascApiKey?.keyId;
+    }
+    else if (process.env.EXPO_ASC_KEY_ID) {
+        return process.env.EXPO_ASC_KEY_ID;
+    }
+    const { ascApiKeyId } = await (0, prompts_1.promptAsync)({
+        type: 'text',
+        name: 'ascApiKeyId',
+        message: `ASC Api Key ID:`,
+        validate: (val) => val !== '',
+    });
+    return ascApiKeyId;
+}
+async function getAscIssuerIdFromEnvironmentOrOptionsAsync(ascApiKey) {
+    if (ascApiKey?.issuerId) {
+        return ascApiKey?.issuerId;
+    }
+    else if (process.env.EXPO_ASC_ISSUER_ID) {
+        return process.env.EXPO_ASC_ISSUER_ID;
+    }
+    const { ascIssuerId } = await (0, prompts_1.promptAsync)({
+        type: 'text',
+        name: 'ascIssuerId',
+        message: `ASC Issuer ID:`,
+        validate: (val) => val !== '',
+    });
+    return ascIssuerId;
+}
+function isAppleTeamType(maybeTeamType) {
+    return maybeTeamType in authenticateTypes_1.AppleTeamType;
+}
+function assertAppleTeamType(maybeTeamType) {
+    if (!isAppleTeamType(maybeTeamType)) {
+        throw new Error(`Invalid Apple Team Type: ${maybeTeamType}. Must be one of ${Object.keys(authenticateTypes_1.AppleTeamType).join(', ')}`);
+    }
+    return maybeTeamType;
+}
+function resolveAppleTeamTypeFromEnvironment() {
+    if (!process.env.EXPO_APPLE_TEAM_TYPE) {
+        return undefined;
+    }
+    return assertAppleTeamType(process.env.EXPO_APPLE_TEAM_TYPE);
+}
+async function getAppleTeamIdFromEnvironmentOrOptionsAsync(options) {
+    if (options.teamId) {
+        return options.teamId;
+    }
+    else if (process.env.EXPO_APPLE_TEAM_ID) {
+        return process.env.EXPO_APPLE_TEAM_ID;
+    }
+    const { appleTeamId } = await (0, prompts_1.promptAsync)({
+        type: 'text',
+        name: 'appleTeamId',
+        message: `Apple Team ID:`,
+        validate: (val) => val !== '',
+    });
+    return appleTeamId;
+}
+async function getAppleTeamTypeFromEnvironmentOrOptionsAsync(options) {
+    if (options.teamType) {
+        return options.teamType;
+    }
+    const appleTeamTypeFromEnvironment = resolveAppleTeamTypeFromEnvironment();
+    if (appleTeamTypeFromEnvironment) {
+        return appleTeamTypeFromEnvironment;
+    }
+    const { appleTeamType } = await (0, prompts_1.promptAsync)({
+        type: 'select',
+        message: 'Select your Apple Team Type:',
+        name: 'appleTeamType',
+        choices: [
+            { title: 'Enterprise', value: authenticateTypes_1.AppleTeamType.IN_HOUSE },
+            { title: 'Company/Organization', value: authenticateTypes_1.AppleTeamType.COMPANY_OR_ORGANIZATION },
+            { title: 'Individual', value: authenticateTypes_1.AppleTeamType.INDIVIDUAL },
+        ],
+    });
+    return appleTeamType;
+}
+async function resolveAppleTeamAsync(options = {}) {
+    const passedTeamType = await getAppleTeamTypeFromEnvironmentOrOptionsAsync(options);
+    return {
+        id: await getAppleTeamIdFromEnvironmentOrOptionsAsync(options),
+        name: options.teamName,
+        inHouse: passedTeamType === authenticateTypes_1.AppleTeamType.IN_HOUSE,
+    };
+}
+function getAppleIdFromEnvironmentOrOptions({ username, password, ...userCredentials }) {
+    const passedAppleId = username || process.env.EXPO_APPLE_ID;
+    // Only resolve the password if the username was provided.
+    const passedAppleIdPassword = passedAppleId
+        ? password || process.env.EXPO_APPLE_PASSWORD
+        : undefined;
+    return {
+        ...userCredentials,
+        username: passedAppleId,
+        password: passedAppleIdPassword,
+    };
+}
+async function promptUsernameAsync() {
+    log_1.default.log('\u203A Log in to your Apple Developer account to continue');
+    // Get the email address that was last used and set it as
+    // the default value for quicker authentication.
+    const lastAppleId = await getCachedUsernameAsync();
+    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);
+    }
+    return username;
+}
+async function cacheUsernameAsync(username) {
+    // If a new email was used then store it as a suggestion for next time.
+    // This functionality is disabled using the keychain mechanism.
+    if (!Keychain.EXPO_NO_KEYCHAIN && username) {
+        const cachedPath = apple_utils_1.JsonFileCache.usernameCachePath();
+        await apple_utils_1.JsonFileCache.cacheAsync(cachedPath, { username });
+    }
+}
+async function promptPasswordAsync({ username, }) {
+    const cachedPassword = await getCachedPasswordAsync({ username });
+    if (cachedPassword) {
+        log_1.default.log(`\u203A Using password for ${username} from your local Keychain`);
+        log_1.default.log(`  ${(0, log_1.learnMore)('https://docs.expo.dev/distribution/security#keychain')}`);
+        return cachedPassword;
+    }
+    // https://docs.expo.dev/distribution/security/#apple-developer-account-credentials
+    log_1.default.log((0, wrap_ansi_1.default)(chalk_1.default.bold(`\u203A The password is only used to authenticate with Apple and never stored on EAS servers`), process.stdout.columns || 80));
+    log_1.default.log(`  ${(0, log_1.learnMore)('https://bit.ly/2VtGWhU')}`);
+    const { password } = await (0, prompts_1.promptAsync)({
+        type: 'password',
+        name: 'password',
+        message: () => `Password (for ${username}):`,
+        validate: (val) => val !== '',
+    });
+    // TODO: Save only after the auth completes successfully.
+    await cachePasswordAsync({ username, password });
+    return password;
+}
+async function getCachedUsernameAsync() {
+    if (Keychain.EXPO_NO_KEYCHAIN) {
+        // Clear last used apple ID.
+        await fs.remove(apple_utils_1.JsonFileCache.usernameCachePath());
+        return null;
+    }
+    const cached = await apple_utils_1.JsonFileCache.getCacheAsync(apple_utils_1.JsonFileCache.usernameCachePath());
+    const lastAppleId = cached?.username ?? null;
+    return typeof lastAppleId === 'string' ? lastAppleId : null;
+}
+/**
+ * Returns the same prefix used by Fastlane in order to potentially share access between services.
+ * [Cite. Fastlane](https://github.com/fastlane/fastlane/blob/f831062fa6f4b216b8ee38949adfe28fc11a0a8e/credentials_manager/lib/credentials_manager/account_manager.rb#L8).
+ *
+ * @param appleId email address
+ */
+function getKeychainServiceName(appleId) {
+    return `deliver.${appleId}`;
+}
+async function deletePasswordAsync({ username, }) {
+    const serviceName = getKeychainServiceName(username);
+    const success = await Keychain.deletePasswordAsync({ username, serviceName });
+    if (success) {
+        log_1.default.log('\u203A Removed Apple ID password from the native Keychain');
+    }
+    return success;
+}
+async function getCachedPasswordAsync({ username, }) {
+    // If the user opts out, delete the password.
+    if (Keychain.EXPO_NO_KEYCHAIN) {
+        await deletePasswordAsync({ username });
+        return null;
+    }
+    const serviceName = getKeychainServiceName(username);
+    return await Keychain.getPasswordAsync({ username, serviceName });
+}
+async function cachePasswordAsync({ username, password }) {
+    if (Keychain.EXPO_NO_KEYCHAIN) {
+        log_1.default.log('\u203A Skip storing Apple ID password in the local Keychain.');
+        return false;
+    }
+    log_1.default.log(`\u203A Saving Apple ID password to the local Keychain`);
+    log_1.default.log(`  ${(0, log_1.learnMore)('https://docs.expo.dev/distribution/security#keychain')}`);
+    const serviceName = getKeychainServiceName(username);
+    return await Keychain.setPasswordAsync({ username, password, serviceName });
+}

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

@@ -0,0 +1,57 @@
+import { UserRole } from '@expo/apple-utils';
+import { DistributionCertificate, ProvisioningProfile, PushKey } from './appstore/Credentials.types';
+import { AppleDevice } from '../../graphql/generated';
+import { CredentialSchema } from '../utils/promptForCredentials';
+export interface AppLookupParams {
+    accountName: string;
+    projectName: string;
+    bundleIdentifier: string;
+}
+export declare function getAppLookupParams(experienceName: string, bundleIdentifier: string): AppLookupParams;
+export interface IosCredentials {
+    appCredentials: IosAppCredentials[];
+    userCredentials: (IosPushCredentials | IosDistCredentials)[];
+}
+export interface IosAppCredentials {
+    experienceName: string;
+    bundleIdentifier: string;
+    pushCredentialsId?: number;
+    distCredentialsId?: number;
+    credentials: {
+        provisioningProfileId?: string;
+        provisioningProfile?: string;
+        devices?: AppleDevice[];
+        teamId?: string;
+        teamName?: string;
+        pushId?: string;
+        pushP12?: string;
+        pushPassword?: string;
+    };
+}
+export interface IosPushCredentials extends PushKey {
+    id: string;
+    type: 'push-key';
+}
+export interface IosDistCredentials extends DistributionCertificate {
+    id: string;
+    type: 'dist-cert';
+}
+export declare const distributionCertificateSchema: CredentialSchema<DistributionCertificate>;
+export type MinimalAscApiKey = {
+    keyP8: string;
+    keyId: string;
+    issuerId: string;
+    teamId?: string;
+    teamName?: string;
+    roles?: UserRole[];
+    name?: string;
+};
+export interface AscApiKeyPath {
+    keyP8Path: string;
+    keyId: string;
+    issuerId: string;
+}
+export declare const ascApiKeyIdSchema: CredentialSchema<Pick<MinimalAscApiKey, 'keyId'>>;
+export declare const ascApiKeyIssuerIdSchema: CredentialSchema<Pick<MinimalAscApiKey, 'issuerId'>>;
+export declare const pushKeySchema: CredentialSchema<PushKey>;
+export declare const provisioningProfileSchema: CredentialSchema<ProvisioningProfile>;

package/build/credentials/ios/credentials.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.provisioningProfileSchema = exports.pushKeySchema = exports.ascApiKeyIssuerIdSchema = exports.ascApiKeyIdSchema = exports.distributionCertificateSchema = void 0;
+exports.getAppLookupParams = getAppLookupParams;
+const tslib_1 = require("tslib");
+const p12Certificate_1 = require("./utils/p12Certificate");
+const provisioningProfile_1 = require("./utils/provisioningProfile");
+const log_1 = tslib_1.__importDefault(require("../../log"));
+function getAppLookupParams(experienceName, bundleIdentifier) {
+    const matchedExperienceName = experienceName.match(/@(.+)\/(.+)/);
+    if (!matchedExperienceName || matchedExperienceName.length < 3) {
+        throw new Error('invalid experience name');
+    }
+    return {
+        accountName: matchedExperienceName[1],
+        projectName: matchedExperienceName[2],
+        bundleIdentifier,
+    };
+}
+exports.distributionCertificateSchema = {
+    name: 'Apple Distribution Certificate',
+    questions: [
+        {
+            field: 'certP12',
+            question: 'Path to P12 file:',
+            type: 'file',
+            base64Encode: true,
+        },
+        {
+            field: 'certPassword',
+            type: 'password',
+            question: 'P12 password:',
+        },
+        {
+            field: 'teamId',
+            type: 'string',
+            question: 'Apple Team ID:',
+        },
+    ],
+    transformResultAsync: async (answers) => {
+        try {
+            const distCertSerialNumber = (0, p12Certificate_1.findP12CertSerialNumber)(answers.certP12, answers.certPassword);
+            return { ...answers, distCertSerialNumber };
+        }
+        catch (error) {
+            log_1.default.warn('Unable to access certificate serial number.');
+            log_1.default.warn('Make sure that certificate and password are correct.');
+            log_1.default.warn(error);
+        }
+        return answers;
+    },
+};
+exports.ascApiKeyIdSchema = {
+    name: 'App Store Connect API Key',
+    questions: [
+        {
+            field: 'keyId',
+            type: 'string',
+            question: 'Key ID:',
+        },
+    ],
+};
+exports.ascApiKeyIssuerIdSchema = {
+    name: 'App Store Connect API Key',
+    questions: [
+        {
+            field: 'issuerId',
+            type: 'string',
+            question: 'Issuer ID:',
+        },
+    ],
+};
+exports.pushKeySchema = {
+    name: 'Apple Push Notifications service key',
+    questions: [
+        {
+            field: 'apnsKeyP8',
+            type: 'file',
+            question: 'Path to P8 file:',
+        },
+        {
+            field: 'apnsKeyId',
+            type: 'string',
+            question: 'Key ID:',
+        },
+        { field: 'teamId', type: 'string', question: 'Apple Team ID:' },
+    ],
+};
+exports.provisioningProfileSchema = {
+    name: 'Apple Provisioning Profile',
+    questions: [
+        {
+            field: 'provisioningProfile',
+            type: 'file',
+            question: 'Path to .mobileprovision file:',
+            base64Encode: true,
+        },
+    ],
+    transformResultAsync: async (answers) => {
+        return {
+            ...answers,
+            ...(0, provisioningProfile_1.readAppleTeam)(answers.provisioningProfile),
+        };
+    },
+};

package/build/credentials/ios/errors.d.ts

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

package/build/credentials/ios/errors.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppleTeamMissingError = void 0;
+class AppleTeamMissingError extends Error {
+    constructor(message) {
+        super(message ?? 'Apple Team is necessary to create Apple App Identifier');
+    }
+}
+exports.AppleTeamMissingError = AppleTeamMissingError;

package/build/credentials/ios/types.d.ts

@@ -0,0 +1,28 @@
+import { JSONObject } from '@expo/json-file';
+import type { XCBuildConfiguration } from 'xcode';
+import { z } from 'zod';
+import { AccountFragment, CommonIosAppCredentialsFragment, IosAppBuildCredentialsFragment } from '../../graphql/generated';
+export interface App {
+    account: AccountFragment;
+    projectName: string;
+}
+export interface Target {
+    targetName: string;
+    buildConfiguration?: string;
+    bundleIdentifier: string;
+    parentBundleIdentifier?: string;
+    entitlements: JSONObject;
+    buildSettings?: XCBuildConfiguration['buildSettings'];
+}
+export interface TargetCredentials {
+    distributionCertificate: {
+        certificateP12: string;
+        certificatePassword: string;
+    };
+    provisioningProfile: string;
+}
+export type IosCredentials = Record<string, TargetCredentials>;
+export type IosAppBuildCredentialsMap = Record<string, IosAppBuildCredentialsFragment>;
+export type IosAppCredentialsMap = Record<string, CommonIosAppCredentialsFragment | null>;
+export declare const booleanLike: z.ZodUnion<readonly [z.ZodBoolean, z.ZodCodec<z.ZodNumber, z.ZodBoolean>, z.ZodCodec<z.ZodString, z.ZodBoolean>]>;
+export declare const stringLike: z.ZodCodec<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodString>;

package/build/credentials/ios/types.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stringLike = exports.booleanLike = void 0;
+const zod_1 = require("zod");
+// `z.coerce.boolean()` does `Boolean(val)` under the hood,
+// which is not what we want. See:
+// https://github.com/colinhacks/zod/issues/2985#issuecomment-2230692578
+exports.booleanLike = zod_1.z.union([
+    zod_1.z.boolean(),
+    zod_1.z.codec(zod_1.z.number(), zod_1.z.boolean(), {
+        decode: n => !!n,
+        encode: b => (b ? 1 : 0),
+    }),
+    zod_1.z.stringbool({ truthy: ['true', 'True'], falsy: ['false', 'False'] }),
+]);
+exports.stringLike = zod_1.z.codec(zod_1.z.union([
+    // We're going to coerce numbers and strings into strings.
+    zod_1.z.number(),
+    zod_1.z.string(),
+    // We do not allow other primitives, like:
+    // - bigints, symbols - because YAML does not support them,
+    // - booleans - because YAML accepts `True` and `true` as boolean input
+    //   and parses both as JS `true` -- if we stringified that,
+    //   we would lose the capital "T" which may not be what the user expects,
+    // - nulls - user should do `"null"` or not pass the property at all.
+]), zod_1.z.string(), {
+    decode: value => {
+        if (typeof value === 'string') {
+            return value;
+        }
+        if (typeof value === 'number') {
+            return String(value);
+        }
+        throw new Error(`Cannot convert ${typeof value} to string: ${value}`);
+    },
+    encode: value => value,
+});

package/build/credentials/ios/utils/authType.d.ts

@@ -0,0 +1,3 @@
+import { RequestContext } from '@expo/apple-utils';
+/** Is the request context App Store Connect only with no access to cookies authentication. */
+export declare function isAppStoreConnectTokenOnlyContext(authContext: RequestContext): boolean;

package/build/credentials/ios/utils/authType.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAppStoreConnectTokenOnlyContext = isAppStoreConnectTokenOnlyContext;
+/** Is the request context App Store Connect only with no access to cookies authentication. */
+function isAppStoreConnectTokenOnlyContext(authContext) {
+    return !authContext.teamId && !!authContext.token;
+}

package/build/credentials/ios/utils/convertHTMLToASCII.d.ts

@@ -0,0 +1,4 @@
+export declare function convertHTMLToASCII({ content, rootUrl, }: {
+    content: string;
+    rootUrl: string;
+}): string;

package/build/credentials/ios/utils/convertHTMLToASCII.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertHTMLToASCII = convertHTMLToASCII;
+const tslib_1 = require("tslib");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+// @ts-expect-error
+const turndown_1 = tslib_1.__importDefault(require("turndown"));
+const wrap_ansi_1 = tslib_1.__importDefault(require("wrap-ansi"));
+const log_1 = require("../../../log");
+const turndownServices = {};
+function getService(rootUrl) {
+    if (turndownServices[rootUrl]) {
+        return turndownServices[rootUrl];
+    }
+    const turndownService = new turndown_1.default();
+    turndownService.addRule('strikethrough', {
+        filter: ['del', 's', 'strike'],
+        replacement(content) {
+            return chalk_1.default.strikethrough(content);
+        },
+    });
+    turndownService.addRule('strong', {
+        filter: ['strong', 'b'],
+        replacement(content) {
+            return chalk_1.default.bold(content);
+        },
+    });
+    turndownService.addRule('emphasis', {
+        filter: ['em', 'i'],
+        replacement(content) {
+            return chalk_1.default.italic(content);
+        },
+    });
+    turndownService.addRule('heading', {
+        filter: ['h1', 'h2', 'h3', 'h4', 'h5', 'h6'],
+        replacement(content) {
+            return '\n' + chalk_1.default.bold(content) + '\n';
+        },
+    });
+    turndownService.addRule('inlineLink', {
+        filter(node, options) {
+            return options.linkStyle === 'inlined' && node.nodeName === 'A' && node.getAttribute('href');
+        },
+        replacement(content, node) {
+            let href = node.getAttribute('href');
+            if (href.startsWith('/')) {
+                href = `${rootUrl}${href}`;
+            }
+            return chalk_1.default.cyan((0, log_1.link)(href, { text: content }));
+        },
+    });
+    turndownServices[rootUrl] = turndownService;
+    return turndownService;
+}
+function convertHTMLToASCII({ content, rootUrl, }) {
+    const service = getService(rootUrl);
+    return (0, wrap_ansi_1.default)(service.turndown(content), process.stdout.columns || 80);
+}