@donotuse/eas-cli 18.5.0-rc.1

package/build/credentials/android/utils/keystore.js

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.keytoolCommandExistsAsync = keytoolCommandExistsAsync;
+exports.generateRandomKeystoreAsync = generateRandomKeystoreAsync;
+const tslib_1 = require("tslib");
+const spawn_async_1 = tslib_1.__importDefault(require("@expo/spawn-async"));
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const crypto_1 = tslib_1.__importDefault(require("crypto"));
+const fs_extra_1 = tslib_1.__importDefault(require("fs-extra"));
+const path_1 = tslib_1.__importDefault(require("path"));
+const uuid_1 = require("uuid");
+const AnalyticsManager_1 = require("../../../analytics/AnalyticsManager");
+const fetch_1 = tslib_1.__importDefault(require("../../../fetch"));
+const generated_1 = require("../../../graphql/generated");
+const KeystoreGenerationUrlMutation_1 = require("../../../graphql/mutations/KeystoreGenerationUrlMutation");
+const log_1 = tslib_1.__importDefault(require("../../../log"));
+const ora_1 = require("../../../ora");
+const paths_1 = require("../../../utils/paths");
+async function keytoolCommandExistsAsync() {
+    try {
+        await (0, spawn_async_1.default)('keytool');
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+var KeystoreCreateStep;
+(function (KeystoreCreateStep) {
+    KeystoreCreateStep["Attempt"] = "attempt";
+    KeystoreCreateStep["Fail"] = "fail";
+    KeystoreCreateStep["Success"] = "success";
+})(KeystoreCreateStep || (KeystoreCreateStep = {}));
+async function generateRandomKeystoreAsync(graphqlClient, analytics, projectId) {
+    const keystoreData = {
+        keystorePassword: crypto_1.default.randomBytes(16).toString('hex'),
+        keyPassword: crypto_1.default.randomBytes(16).toString('hex'),
+        keyAlias: crypto_1.default.randomBytes(16).toString('hex'),
+    };
+    return await createKeystoreAsync(graphqlClient, analytics, keystoreData, projectId);
+}
+async function createKeystoreAsync(graphqlClient, analytics, keystoreParams, projectId) {
+    analytics.logEvent(AnalyticsManager_1.BuildEvent.ANDROID_KEYSTORE_CREATE, {
+        project_id: projectId,
+        step: KeystoreCreateStep.Attempt,
+        type: generated_1.AndroidKeystoreType.Jks,
+    });
+    try {
+        let keystore;
+        let localAttempt = false;
+        if (await keytoolCommandExistsAsync()) {
+            try {
+                localAttempt = true;
+                keystore = await createKeystoreLocallyAsync(keystoreParams);
+            }
+            catch {
+                log_1.default.error('Failed to generate keystore locally. Falling back to cloud generation.');
+            }
+        }
+        if (!keystore) {
+            keystore = await createKeystoreInCloudAsync(graphqlClient, keystoreParams, {
+                showKeytoolDetectionMsg: !localAttempt,
+            });
+        }
+        analytics.logEvent(AnalyticsManager_1.BuildEvent.ANDROID_KEYSTORE_CREATE, {
+            project_id: projectId,
+            step: KeystoreCreateStep.Success,
+            type: generated_1.AndroidKeystoreType.Jks,
+        });
+        return keystore;
+    }
+    catch (error) {
+        analytics.logEvent(AnalyticsManager_1.BuildEvent.ANDROID_KEYSTORE_CREATE, {
+            project_id: projectId,
+            step: KeystoreCreateStep.Fail,
+            reason: error.message,
+            type: generated_1.AndroidKeystoreType.Jks,
+        });
+        throw error;
+    }
+}
+async function createKeystoreLocallyAsync(keystoreParams) {
+    await fs_extra_1.default.mkdirp((0, paths_1.getTmpDirectory)());
+    const keystorePath = path_1.default.join((0, paths_1.getTmpDirectory)(), `${(0, uuid_1.v4)()}-keystore.jks`);
+    try {
+        await (0, spawn_async_1.default)('keytool', [
+            '-genkey',
+            '-v',
+            '-storetype',
+            'JKS',
+            '-storepass',
+            keystoreParams.keystorePassword,
+            '-keypass',
+            keystoreParams.keyPassword,
+            '-keystore',
+            keystorePath,
+            '-alias',
+            keystoreParams.keyAlias,
+            '-keyalg',
+            'RSA',
+            '-keysize',
+            '2048',
+            '-validity',
+            '10000',
+            '-dname',
+            `CN=,OU=,O=,L=,S=,C=US`,
+        ]);
+        return {
+            ...keystoreParams,
+            keystore: await fs_extra_1.default.readFile(keystorePath, 'base64'),
+            type: generated_1.AndroidKeystoreType.Jks,
+        };
+    }
+    finally {
+        await fs_extra_1.default.remove(keystorePath);
+    }
+}
+async function createKeystoreInCloudAsync(graphqlClient, keystoreParams, { showKeytoolDetectionMsg = true } = {}) {
+    if (showKeytoolDetectionMsg) {
+        log_1.default.log(`Detected that you do not have ${chalk_1.default.bold('keytool')} installed locally.`);
+    }
+    const spinner = (0, ora_1.ora)('Generating keystore in the cloud...').start();
+    try {
+        const url = await KeystoreGenerationUrlMutation_1.KeystoreGenerationUrlMutation.createKeystoreGenerationUrlAsync(graphqlClient);
+        const response = await (0, fetch_1.default)(url, {
+            method: 'POST',
+            body: JSON.stringify(keystoreParams),
+            headers: { 'Content-Type': 'application/json' },
+        });
+        const result = (await response.json());
+        spinner.succeed();
+        return {
+            type: generated_1.AndroidKeystoreType.Jks,
+            keystore: result.keystoreBase64,
+            keystorePassword: result.keystorePassword,
+            keyAlias: result.keyAlias,
+            keyPassword: result.keyPassword,
+        };
+    }
+    catch (err) {
+        spinner.fail();
+        throw err;
+    }
+}

package/build/credentials/android/utils/keystoreNew.d.ts

@@ -0,0 +1,5 @@
+import { AndroidKeystoreType } from '../../../graphql/generated';
+import { Keystore, KeystoreWithType } from '../credentials';
+export declare function getKeystoreWithType(keystore: Keystore): KeystoreWithType;
+export declare function getKeystoreType(keystore: Keystore): AndroidKeystoreType;
+export declare function validateKeystore(keystore: KeystoreWithType): void;

package/build/credentials/android/utils/keystoreNew.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getKeystoreWithType = getKeystoreWithType;
+exports.getKeystoreType = getKeystoreType;
+exports.validateKeystore = validateKeystore;
+const tslib_1 = require("tslib");
+const pkcs12_1 = require("@expo/pkcs12");
+const jks_js_1 = tslib_1.__importDefault(require("jks-js"));
+const generated_1 = require("../../../graphql/generated");
+const log_1 = tslib_1.__importDefault(require("../../../log"));
+function getKeystoreWithType(keystore) {
+    const type = getKeystoreType(keystore);
+    return { ...keystore, type };
+}
+function getKeystoreType(keystore) {
+    if (isPKCSKeystore(keystore)) {
+        return generated_1.AndroidKeystoreType.Pkcs12;
+    }
+    else if (isJKSKeystore(keystore)) {
+        return generated_1.AndroidKeystoreType.Jks;
+    }
+    return generated_1.AndroidKeystoreType.Unknown;
+}
+function isPKCSKeystore(keystore) {
+    try {
+        (0, pkcs12_1.parsePKCS12)(keystore.keystore, keystore.keystorePassword);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function isJKSKeystore(keystore) {
+    try {
+        jks_js_1.default.parseJks(Buffer.from(keystore.keystore, 'base64'), keystore.keystorePassword);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function validateKeystore(keystore) {
+    if (keystore.type === generated_1.AndroidKeystoreType.Jks) {
+        getPemFromJksKeystore(keystore);
+    }
+    else if (keystore.type === generated_1.AndroidKeystoreType.Pkcs12) {
+        getX509Asn1FromPKCS12Keystore(keystore.keystore, keystore.keystorePassword, keystore.keyAlias);
+    }
+    else if (keystore.type === generated_1.AndroidKeystoreType.Unknown) {
+        log_1.default.warn('Unknown keystore type, skipping validation.');
+    }
+    else {
+        log_1.default.warn(`Unsupported keystore type: ${keystore.type}, skipping validation.`);
+    }
+}
+function getPemFromJksKeystore(keystore) {
+    const keystoreEntries = jks_js_1.default.parseJks(Buffer.from(keystore.keystore, 'base64'), keystore.keystorePassword);
+    // keystore entries are case insensitive in both keytool and jks-js implementations
+    const keystoreEntry = keystoreEntries.find((entry) => entry.alias.toLowerCase() === keystore.keyAlias.toLowerCase());
+    if (!keystoreEntry) {
+        throw new Error(`JKS Keystore does not contain alias: ${keystore.keyAlias}`);
+    }
+    const { protectedPrivateKey } = keystoreEntry;
+    try {
+        return jks_js_1.default.decrypt(protectedPrivateKey, keystore.keyPassword);
+    }
+    catch (e) {
+        throw new Error(`${e.message}: Check that your key password is correct`);
+    }
+}
+function getX509Asn1FromPKCS12Keystore(p12BufferOrBase64String, maybePassword, keyAlias) {
+    let x509Asn1;
+    try {
+        const p12 = (0, pkcs12_1.parsePKCS12)(p12BufferOrBase64String, maybePassword);
+        x509Asn1 = (0, pkcs12_1.getX509Asn1ByFriendlyName)(p12, keyAlias);
+    }
+    catch (e) {
+        throw new Error(`Invalid PKCS#12 (.p12) keystore: ${e.message}`);
+    }
+    if (!x509Asn1) {
+        throw new Error(`PKCS#12 keystore: Unable to get certificate under alias: ${keyAlias}. Run this to find the available aliases: keytool -list -v -keystore [your-keystore-path]`);
+    }
+    return x509Asn1;
+}

package/build/credentials/android/utils/printCredentials.d.ts

@@ -0,0 +1,8 @@
+import { AndroidKeystoreFragment, CommonAndroidAppCredentialsFragment } from '../../../graphql/generated';
+import { AppLookupParams } from '../api/GraphqlClient';
+export declare function displayEmptyAndroidCredentials(appLookupParams: AppLookupParams): void;
+export declare function displayAndroidKeystore(keystore: AndroidKeystoreFragment): void;
+export declare function displayAndroidAppCredentials({ appLookupParams, appCredentials, }: {
+    appLookupParams: AppLookupParams;
+    appCredentials: CommonAndroidAppCredentialsFragment | null;
+}): void;

package/build/credentials/android/utils/printCredentials.js

@@ -0,0 +1,160 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.displayEmptyAndroidCredentials = displayEmptyAndroidCredentials;
+exports.displayAndroidKeystore = displayAndroidKeystore;
+exports.displayAndroidAppCredentials = displayAndroidAppCredentials;
+const tslib_1 = require("tslib");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const generated_1 = require("../../../graphql/generated");
+const log_1 = tslib_1.__importDefault(require("../../../log"));
+const date_1 = require("../../../utils/date");
+const formatFields_1 = tslib_1.__importDefault(require("../../../utils/formatFields"));
+const BuildCredentialsUtils_1 = require("../actions/BuildCredentialsUtils");
+function displayEmptyAndroidCredentials(appLookupParams) {
+    const { projectName, androidApplicationIdentifier } = appLookupParams;
+    const fields = [
+        { label: 'Android Credentials', value: '' },
+        { label: 'Project', value: projectName },
+        { label: 'Application Identifier', value: androidApplicationIdentifier },
+    ];
+    log_1.default.log((0, formatFields_1.default)(fields, { labelFormat: chalk_1.default.cyan.bold }));
+    log_1.default.log((0, formatFields_1.default)([{ label: 'No credentials set up yet!', value: '' }]));
+    log_1.default.newLine();
+}
+function displayAndroidFcmCredentials(appCredentials) {
+    const maybeFcm = appCredentials.androidFcm;
+    log_1.default.log((0, formatFields_1.default)([{ label: 'Push Notifications (FCM Legacy)', value: '' }], {
+        labelFormat: chalk_1.default.cyan.bold,
+    }));
+    if (!maybeFcm) {
+        log_1.default.log((0, formatFields_1.default)([{ label: '', value: 'None assigned yet' }]));
+        log_1.default.newLine();
+        return;
+    }
+    const { snippet, version, updatedAt } = maybeFcm;
+    const fields = [];
+    if (version === generated_1.AndroidFcmVersion.Legacy) {
+        const { firstFourCharacters, lastFourCharacters } = snippet;
+        fields.push({ label: 'Key', value: `${firstFourCharacters}...${lastFourCharacters}` });
+    }
+    else if (version === generated_1.AndroidFcmVersion.V1) {
+        const { projectId, serviceAccountEmail, clientId, keyId } = snippet;
+        fields.push({ label: 'Project ID', value: projectId });
+        fields.push({ label: 'Client Email', value: serviceAccountEmail });
+        fields.push({ label: 'Client ID', value: clientId ?? 'Unknown' });
+        fields.push({ label: 'Private Key ID', value: keyId });
+    }
+    fields.push({ label: 'Updated', value: `${(0, date_1.fromNow)(new Date(updatedAt))} ago` });
+    log_1.default.log((0, formatFields_1.default)(fields, { labelFormat: chalk_1.default.cyan.bold }));
+    log_1.default.newLine();
+}
+function displayGoogleServiceAccountKeyForSubmissions(appCredentials) {
+    const maybeGsaKey = appCredentials.googleServiceAccountKeyForSubmissions;
+    log_1.default.log((0, formatFields_1.default)([{ label: 'Submissions: Google Service Account Key for Play Store Submissions', value: '' }], {
+        labelFormat: chalk_1.default.cyan.bold,
+    }));
+    if (!maybeGsaKey) {
+        log_1.default.log((0, formatFields_1.default)([{ label: '', value: 'None assigned yet' }]));
+        log_1.default.newLine();
+        return;
+    }
+    const { projectIdentifier, privateKeyIdentifier, clientEmail, clientIdentifier, updatedAt } = maybeGsaKey;
+    const fields = [
+        { label: 'Project ID', value: projectIdentifier },
+        { label: 'Client Email', value: clientEmail },
+        { label: 'Client ID', value: clientIdentifier },
+        { label: 'Private Key ID', value: privateKeyIdentifier },
+        { label: 'Updated', value: `${(0, date_1.fromNow)(new Date(updatedAt))} ago` },
+    ];
+    log_1.default.log((0, formatFields_1.default)(fields, { labelFormat: chalk_1.default.cyan.bold }));
+    log_1.default.newLine();
+}
+function displayGoogleServiceAccountKeyForFcmV1(appCredentials) {
+    const maybeGsaKey = appCredentials.googleServiceAccountKeyForFcmV1;
+    log_1.default.log((0, formatFields_1.default)([{ label: 'Push Notifications (FCM V1): Google Service Account Key For FCM V1', value: '' }], {
+        labelFormat: chalk_1.default.cyan.bold,
+    }));
+    if (!maybeGsaKey) {
+        log_1.default.log((0, formatFields_1.default)([{ label: '', value: 'None assigned yet' }]));
+        log_1.default.newLine();
+        return;
+    }
+    const { projectIdentifier, privateKeyIdentifier, clientEmail, clientIdentifier, updatedAt } = maybeGsaKey;
+    const fields = [
+        { label: 'Project ID', value: projectIdentifier },
+        { label: 'Client Email', value: clientEmail },
+        { label: 'Client ID', value: clientIdentifier },
+        { label: 'Private Key ID', value: privateKeyIdentifier },
+        { label: 'Updated', value: `${(0, date_1.fromNow)(new Date(updatedAt))} ago` },
+    ];
+    log_1.default.log((0, formatFields_1.default)(fields, { labelFormat: chalk_1.default.cyan.bold }));
+    log_1.default.newLine();
+}
+function displayEASAndroidAppCredentials(appCredentials) {
+    displayAndroidFcmCredentials(appCredentials);
+    displayGoogleServiceAccountKeyForFcmV1(appCredentials);
+    displayGoogleServiceAccountKeyForSubmissions(appCredentials);
+    const sortedBuildCredentialsList = (0, BuildCredentialsUtils_1.sortBuildCredentials)(appCredentials.androidAppBuildCredentialsList);
+    for (const buildCredentials of sortedBuildCredentialsList) {
+        displayAndroidBuildCredentials(buildCredentials);
+    }
+}
+function formatFingerprint(fingerprint) {
+    if (!fingerprint) {
+        return 'unavailable';
+    }
+    const uppercaseFingerprint = fingerprint.toUpperCase();
+    const bytes = [];
+    for (let i = 0; i < uppercaseFingerprint.length; i++) {
+        const halfByte = uppercaseFingerprint.charAt(i);
+        if (i % 2 === 0) {
+            bytes.push(halfByte); // first half of the byte
+        }
+        else {
+            bytes[bytes.length - 1] += halfByte; // second half of the byte
+        }
+    }
+    return bytes.join(':');
+}
+function displayAndroidBuildCredentials(buildCredentials) {
+    const { isDefault, name } = buildCredentials;
+    log_1.default.log((0, formatFields_1.default)([{ label: `Configuration: ${name}${isDefault ? ' (Default)' : ''}`, value: '' }], {
+        labelFormat: chalk_1.default.cyan.bold,
+    }));
+    const maybeKeystore = buildCredentials.androidKeystore;
+    log_1.default.log((0, formatFields_1.default)([{ label: 'Keystore', value: '' }], {
+        labelFormat: chalk_1.default.cyan.bold,
+    }));
+    if (maybeKeystore) {
+        displayAndroidKeystore(maybeKeystore);
+    }
+    else {
+        log_1.default.log((0, formatFields_1.default)([{ label: '', value: 'None assigned yet' }]));
+    }
+    log_1.default.newLine();
+}
+function displayAndroidKeystore(keystore) {
+    const { keyAlias, type, md5CertificateFingerprint, sha1CertificateFingerprint, sha256CertificateFingerprint, updatedAt, } = keystore;
+    const fields = [
+        { label: 'Type', value: type },
+        { label: 'Key Alias', value: keyAlias },
+        { label: 'MD5 Fingerprint', value: formatFingerprint(md5CertificateFingerprint ?? null) },
+        { label: 'SHA1 Fingerprint', value: formatFingerprint(sha1CertificateFingerprint ?? null) },
+        { label: 'SHA256 Fingerprint', value: formatFingerprint(sha256CertificateFingerprint ?? null) },
+        { label: 'Updated', value: `${(0, date_1.fromNow)(new Date(updatedAt))} ago` },
+    ];
+    log_1.default.log((0, formatFields_1.default)(fields, { labelFormat: chalk_1.default.cyan.bold }));
+}
+function displayAndroidAppCredentials({ appLookupParams, appCredentials, }) {
+    const { projectName, androidApplicationIdentifier } = appLookupParams;
+    const fields = [
+        { label: 'Android Credentials', value: '' },
+        { label: 'Project', value: projectName },
+        { label: 'Application Identifier', value: androidApplicationIdentifier },
+    ];
+    log_1.default.log((0, formatFields_1.default)(fields, { labelFormat: chalk_1.default.cyan.bold }));
+    log_1.default.newLine();
+    if (appCredentials) {
+        displayEASAndroidAppCredentials(appCredentials);
+    }
+}

package/build/credentials/context.d.ts

@@ -0,0 +1,50 @@
+import { ExpoConfig } from '@expo/config';
+import { Env } from '@expo/eas-build-job';
+import { EasJson } from '@expo/eas-json';
+import * as AndroidGraphqlClient from './android/api/GraphqlClient';
+import * as IosGraphqlClient from './ios/api/GraphqlClient';
+import AppStoreApi from './ios/appstore/AppStoreApi';
+import { Analytics } from '../analytics/AnalyticsManager';
+import { ExpoGraphqlClient } from '../commandUtils/context/contextUtils/createGraphqlClient';
+import { Actor } from '../user/User';
+import { Client } from '../vcs/vcs';
+export type CredentialsContextProjectInfo = {
+    exp: ExpoConfig;
+    projectId: string;
+};
+export declare class CredentialsContext {
+    private readonly options;
+    readonly android: typeof AndroidGraphqlClient;
+    readonly appStore: AppStoreApi;
+    readonly ios: typeof IosGraphqlClient;
+    readonly nonInteractive: boolean;
+    readonly autoAcceptCredentialReuse: boolean;
+    readonly freezeCredentials: boolean;
+    readonly projectDir: string;
+    readonly user: Actor;
+    readonly graphqlClient: ExpoGraphqlClient;
+    readonly analytics: Analytics;
+    readonly vcsClient: Client;
+    readonly easJsonCliConfig?: EasJson['cli'];
+    readonly usesBroadcastPushNotifications: boolean;
+    private shouldAskAuthenticateAppStore;
+    private readonly projectInfo;
+    constructor(options: {
+        projectInfo: CredentialsContextProjectInfo | null;
+        easJsonCliConfig?: EasJson['cli'];
+        nonInteractive: boolean;
+        projectDir: string;
+        user: Actor;
+        graphqlClient: ExpoGraphqlClient;
+        analytics: Analytics;
+        vcsClient: Client;
+        freezeCredentials?: boolean;
+        autoAcceptCredentialReuse?: boolean;
+        env?: Env;
+    });
+    get hasProjectContext(): boolean;
+    getExpoConfigAsync(): Promise<ExpoConfig>;
+    getProjectIdAsync(): Promise<string>;
+    ensureProjectContextAsync(): Promise<void>;
+    bestEffortAppStoreAuthenticateAsync(): Promise<void>;
+}

package/build/credentials/context.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CredentialsContext = void 0;
+const tslib_1 = require("tslib");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const AndroidGraphqlClient = tslib_1.__importStar(require("./android/api/GraphqlClient"));
+const IosGraphqlClient = tslib_1.__importStar(require("./ios/api/GraphqlClient"));
+const AppStoreApi_1 = tslib_1.__importDefault(require("./ios/appstore/AppStoreApi"));
+const authenticateTypes_1 = require("./ios/appstore/authenticateTypes");
+const log_1 = tslib_1.__importDefault(require("../log"));
+const expoConfig_1 = require("../project/expoConfig");
+const prompts_1 = require("../prompts");
+class CredentialsContext {
+    options;
+    android = AndroidGraphqlClient;
+    appStore = new AppStoreApi_1.default();
+    ios = IosGraphqlClient;
+    nonInteractive;
+    autoAcceptCredentialReuse;
+    freezeCredentials = false;
+    projectDir;
+    user;
+    graphqlClient;
+    analytics;
+    vcsClient;
+    easJsonCliConfig;
+    usesBroadcastPushNotifications;
+    shouldAskAuthenticateAppStore = true;
+    projectInfo;
+    constructor(options) {
+        this.options = options;
+        this.easJsonCliConfig = options.easJsonCliConfig;
+        this.projectDir = options.projectDir;
+        this.user = options.user;
+        this.graphqlClient = options.graphqlClient;
+        this.analytics = options.analytics;
+        this.vcsClient = options.vcsClient;
+        this.nonInteractive = options.nonInteractive ?? false;
+        this.autoAcceptCredentialReuse = options.autoAcceptCredentialReuse ?? false;
+        this.projectInfo = options.projectInfo;
+        this.freezeCredentials = options.freezeCredentials ?? false;
+        this.usesBroadcastPushNotifications =
+            options.projectInfo?.exp.ios?.usesBroadcastPushNotifications ?? false;
+    }
+    get hasProjectContext() {
+        return !!this.projectInfo;
+    }
+    async getExpoConfigAsync() {
+        await this.ensureProjectContextAsync();
+        return this.projectInfo.exp;
+    }
+    async getProjectIdAsync() {
+        await this.ensureProjectContextAsync();
+        return this.projectInfo.projectId;
+    }
+    async ensureProjectContextAsync() {
+        if (this.hasProjectContext) {
+            return;
+        }
+        // trigger getConfig error
+        await (0, expoConfig_1.getPrivateExpoConfigAsync)(this.options.projectDir);
+    }
+    async bestEffortAppStoreAuthenticateAsync() {
+        if (!!this.appStore.authCtx || !this.shouldAskAuthenticateAppStore) {
+            // skip prompts if already have apple ctx or already asked about it
+            return;
+        }
+        if (this.nonInteractive) {
+            return;
+        }
+        if (this.appStore.defaultAuthenticationMode === authenticateTypes_1.AuthenticationMode.API_KEY) {
+            await this.appStore.ensureAuthenticatedAsync();
+            return;
+        }
+        log_1.default.log(chalk_1.default.green('If you provide your Apple account credentials we will be able to generate all necessary build credentials and fully validate them.'));
+        log_1.default.log(chalk_1.default.green('This is optional, but without Apple account access you will need to provide all the missing values manually and we can only run minimal validation on them.'));
+        const confirm = await (0, prompts_1.confirmAsync)({
+            message: `Do you want to log in to your Apple account?`,
+        });
+        if (confirm) {
+            await this.appStore.ensureAuthenticatedAsync();
+        }
+        else {
+            log_1.default.log(chalk_1.default.green('No problem! 👌 If any of the next steps will require Apple account access we will ask you again about it.'));
+        }
+        this.shouldAskAuthenticateAppStore = false;
+    }
+}
+exports.CredentialsContext = CredentialsContext;

package/build/credentials/credentialsJson/read.d.ts

@@ -0,0 +1,7 @@
+import { AndroidCredentials, IosCredentials } from './types';
+import { Target } from '../ios/types';
+export declare function readAndroidCredentialsAsync(projectDir: string): Promise<AndroidCredentials>;
+export declare function readIosCredentialsAsync(projectDir: string, applicationTarget: Target): Promise<IosCredentials>;
+export declare function readRawAsync(projectDir: string, { throwIfMissing }?: {
+    throwIfMissing?: boolean | undefined;
+}): Promise<any>;

package/build/credentials/credentialsJson/read.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readAndroidCredentialsAsync = readAndroidCredentialsAsync;
+exports.readIosCredentialsAsync = readIosCredentialsAsync;
+exports.readRawAsync = readRawAsync;
+const tslib_1 = require("tslib");
+const fs_extra_1 = tslib_1.__importDefault(require("fs-extra"));
+const path_1 = tslib_1.__importDefault(require("path"));
+const types_1 = require("./types");
+const utils_1 = require("./utils");
+async function readAndroidCredentialsAsync(projectDir) {
+    const credentialsJson = await readAsync(projectDir);
+    if (!credentialsJson.android) {
+        throw new Error('Android credentials are missing in credentials.json');
+    }
+    const keystoreInfo = credentialsJson.android.keystore;
+    return {
+        keystore: {
+            keystore: await fs_extra_1.default.readFile(getAbsolutePath(projectDir, keystoreInfo.keystorePath), 'base64'),
+            keystorePassword: keystoreInfo.keystorePassword,
+            keyAlias: keystoreInfo.keyAlias,
+            keyPassword: keystoreInfo.keyPassword,
+        },
+    };
+}
+async function readIosCredentialsAsync(projectDir, applicationTarget) {
+    const credentialsJson = await readAsync(projectDir);
+    if (!credentialsJson.ios) {
+        throw new Error('iOS credentials are missing in credentials.json');
+    }
+    if (isCredentialsMap(credentialsJson.ios)) {
+        const targets = Object.keys(credentialsJson.ios);
+        const iosCredentials = {};
+        for (const target of targets) {
+            iosCredentials[target] = await readCredentialsForTargetAsync(projectDir, credentialsJson.ios[target]);
+        }
+        return iosCredentials;
+    }
+    else {
+        const applicationTargetCredentials = await readCredentialsForTargetAsync(projectDir, credentialsJson.ios);
+        return {
+            [applicationTarget.targetName]: applicationTargetCredentials,
+        };
+    }
+}
+function isCredentialsMap(ios) {
+    return typeof ios.provisioningProfilePath !== 'string';
+}
+async function readCredentialsForTargetAsync(projectDir, targetCredentials) {
+    return {
+        provisioningProfile: await fs_extra_1.default.readFile(getAbsolutePath(projectDir, targetCredentials.provisioningProfilePath), 'base64'),
+        distributionCertificate: {
+            certificateP12: await fs_extra_1.default.readFile(getAbsolutePath(projectDir, targetCredentials.distributionCertificate.path), 'base64'),
+            certificatePassword: targetCredentials.distributionCertificate.password,
+        },
+    };
+}
+async function readAsync(projectDir) {
+    const credentialsJSONRaw = await readRawAsync(projectDir);
+    const { value: credentialsJson, error } = types_1.CredentialsJsonSchema.validate(credentialsJSONRaw, {
+        stripUnknown: true,
+        convert: true,
+        abortEarly: false,
+    });
+    if (error) {
+        throw new Error(`credentials.json is not valid [${error.toString()}]`);
+    }
+    return credentialsJson;
+}
+async function readRawAsync(projectDir, { throwIfMissing = true } = {}) {
+    const credentialsJsonFilePath = (0, utils_1.getCredentialsJsonPath)(projectDir);
+    if (!(await fs_extra_1.default.pathExists(credentialsJsonFilePath))) {
+        if (throwIfMissing) {
+            throw new Error('credentials.json does not exist in the project root directory');
+        }
+        else {
+            return null;
+        }
+    }
+    try {
+        const credentialsJSONContents = await fs_extra_1.default.readFile(credentialsJsonFilePath, 'utf8');
+        return JSON.parse(credentialsJSONContents);
+    }
+    catch {
+        throw new Error(`credentials.json must exist in the project root directory and contain a valid JSON`);
+    }
+}
+function getAbsolutePath(projectDir, filePath) {
+    return path_1.default.isAbsolute(filePath) ? filePath : path_1.default.join(projectDir, filePath);
+}

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

@@ -0,0 +1,34 @@
+import Joi from 'joi';
+import { Keystore } from '../android/credentials';
+export interface CredentialsJson {
+    android?: CredentialsJsonAndroidCredentials;
+    ios?: CredentialsJsonIosTargetCredentials | CredentialsJsonIosCredentials;
+}
+export interface CredentialsJsonAndroidCredentials {
+    keystore: {
+        keystorePath: string;
+        keystorePassword: string;
+        keyAlias: string;
+        keyPassword?: string;
+    };
+}
+export interface CredentialsJsonIosTargetCredentials {
+    provisioningProfilePath: string;
+    distributionCertificate: {
+        path: string;
+        password: string;
+    };
+}
+export type CredentialsJsonIosCredentials = Record<string, CredentialsJsonIosTargetCredentials>;
+export interface AndroidCredentials {
+    keystore: Keystore;
+}
+export interface IosTargetCredentials {
+    provisioningProfile: string;
+    distributionCertificate: {
+        certificateP12: string;
+        certificatePassword: string;
+    };
+}
+export type IosCredentials = Record<string, IosTargetCredentials>;
+export declare const CredentialsJsonSchema: Joi.ObjectSchema<any>;