eas-cli 0.51.0 → 0.53.1

package/build/metadata/config.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAppleWriter = exports.createAppleReader = exports.validateConfig = void 0;
+const tslib_1 = require("tslib");
+const ajv_1 = tslib_1.__importDefault(require("ajv"));
+const assert_1 = tslib_1.__importDefault(require("assert"));
+const reader_1 = require("./apple/config/reader");
+const writer_1 = require("./apple/config/writer");
+/**
+ * Run the JSON Schema validation to normalize defaults and flag early config errors.
+ * This includes validating the known store limitations for every configurable property.
+ */
+function validateConfig(config) {
+    const validator = new ajv_1.default({ allErrors: true, useDefaults: true })
+        .addMetaSchema(require('ajv/lib/refs/json-schema-draft-06.json'))
+        .compile(require('../../schema/metadata-0.json'));
+    const valid = validator(config);
+    return { valid, errors: validator.errors || [] };
+}
+exports.validateConfig = validateConfig;
+/** Create a versioned deserializer to fetch App Store data from the store configuration. */
+function createAppleReader(config) {
+    (0, assert_1.default)(config.configVersion === 0, 'Unsupported store configuration version');
+    (0, assert_1.default)(config.apple, 'No apple configuration found');
+    return new reader_1.AppleConfigReader(config.apple);
+}
+exports.createAppleReader = createAppleReader;
+/** Create the serializer to write the App Store to the store configuration. */
+function createAppleWriter() {
+    return new writer_1.AppleConfigWriter();
+}
+exports.createAppleWriter = createAppleWriter;

package/build/metadata/context.d.ts

@@ -0,0 +1,46 @@
+/// <reference types="@expo/apple-utils/ts-declarations/expo__app-store" />
+import { App, Session } from '@expo/apple-utils';
+import { ExpoConfig } from '@expo/config';
+import { Platform } from '@expo/eas-build-job';
+import { SubmitProfile } from '@expo/eas-json';
+import { CredentialsContext } from '../credentials/context';
+import { Actor } from '../user/User';
+export declare type MetadataContext = {
+    /** Submission profile platform to use */
+    platform: Platform.IOS;
+    /** Resolved submission profile configuration */
+    profile: SubmitProfile<Platform.IOS>;
+    /** Configured store config path, relative from projectDir (defaults to store.config.json) */
+    metadataPath: string;
+    /** Authenticated Expo account */
+    user: Actor;
+    /** The store credentials manager */
+    credentialsCtx: CredentialsContext;
+    /** The app bundle identifier to use for the store */
+    bundleIdentifier: string;
+    /** Root of the Expo project directory */
+    projectDir: string;
+    /** Resolved Expo app configuration */
+    exp: ExpoConfig;
+};
+export declare type MetadataAppStoreAuthentication = {
+    /** The root entity of the App store */
+    app: App;
+    /** The authentication state we used to fetch the root entity */
+    auth: Partial<Session.AuthState>;
+};
+/**
+ * Metadata uses the submission profile to find the configured metadata filename.
+ * Note, only iOS is supported for metadata right now.
+ */
+export declare function createMetadataContextAsync(params: {
+    projectDir: string;
+    credentialsCtx: CredentialsContext;
+    exp?: ExpoConfig;
+    profileName?: string;
+}): Promise<MetadataContext>;
+/**
+ * To start syncing ASC entities, we need access to the apple utils App instance.
+ * This ensures we are authenticated and have the app instance ready to use.
+ */
+export declare function ensureMetadataAppStoreAuthenticatedAsync({ credentialsCtx, bundleIdentifier, }: MetadataContext): Promise<MetadataAppStoreAuthentication>;

package/build/metadata/context.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureMetadataAppStoreAuthenticatedAsync = exports.createMetadataContextAsync = void 0;
+const tslib_1 = require("tslib");
+const apple_utils_1 = require("@expo/apple-utils");
+const eas_build_job_1 = require("@expo/eas-build-job");
+const assert_1 = tslib_1.__importDefault(require("assert"));
+const authenticate_1 = require("../credentials/ios/appstore/authenticate");
+const expoConfig_1 = require("../project/expoConfig");
+const bundleIdentifier_1 = require("../project/ios/bundleIdentifier");
+const actions_1 = require("../user/actions");
+const profiles_1 = require("../utils/profiles");
+/**
+ * Metadata uses the submission profile to find the configured metadata filename.
+ * Note, only iOS is supported for metadata right now.
+ */
+async function createMetadataContextAsync(params) {
+    var _a, _b;
+    const submissionProfiles = await (0, profiles_1.getProfilesAsync)({
+        type: 'submit',
+        platforms: [eas_build_job_1.Platform.IOS],
+        projectDir: params.projectDir,
+        profileName: params.profileName,
+    });
+    const submissionProfile = submissionProfiles.find(profile => profile.platform === eas_build_job_1.Platform.IOS);
+    (0, assert_1.default)(submissionProfile, 'Could not resolve the iOS submission profile, only iOS is supported for metadata');
+    const iosSubmissionProfile = submissionProfile.profile;
+    const exp = (_a = params.exp) !== null && _a !== void 0 ? _a : (0, expoConfig_1.getExpoConfig)(params.projectDir);
+    const user = await (0, actions_1.ensureLoggedInAsync)();
+    const bundleIdentifier = await (0, bundleIdentifier_1.getBundleIdentifierAsync)(params.projectDir, exp);
+    return {
+        platform: eas_build_job_1.Platform.IOS,
+        profile: iosSubmissionProfile,
+        metadataPath: (_b = iosSubmissionProfile.metadataPath) !== null && _b !== void 0 ? _b : 'store.config.json',
+        user,
+        credentialsCtx: params.credentialsCtx,
+        bundleIdentifier,
+        projectDir: params.projectDir,
+        exp,
+    };
+}
+exports.createMetadataContextAsync = createMetadataContextAsync;
+/**
+ * To start syncing ASC entities, we need access to the apple utils App instance.
+ * This ensures we are authenticated and have the app instance ready to use.
+ */
+async function ensureMetadataAppStoreAuthenticatedAsync({ credentialsCtx, bundleIdentifier, }) {
+    const authCtx = await credentialsCtx.appStore.ensureAuthenticatedAsync();
+    (0, assert_1.default)(authCtx.authState, 'Failed to authenticate with App Store Connect');
+    // TODO: improve error handling by mentioning possible configuration errors
+    const app = await apple_utils_1.App.findAsync((0, authenticate_1.getRequestContext)(authCtx), { bundleId: bundleIdentifier });
+    (0, assert_1.default)(app, `Failed to load app "${bundleIdentifier}" from App Store Connect`);
+    return { app, auth: authCtx.authState };
+}
+exports.ensureMetadataAppStoreAuthenticatedAsync = ensureMetadataAppStoreAuthenticatedAsync;

package/build/metadata/download.d.ts

@@ -0,0 +1,6 @@
+import { MetadataContext } from './context';
+/**
+ * Generate a local store configuration from the stores.
+ * Note, only App Store is supported at this time.
+ */
+export declare function downloadMetadataAsync(metadataCtx: MetadataContext): Promise<string>;

package/build/metadata/download.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.downloadMetadataAsync = void 0;
+const tslib_1 = require("tslib");
+const fs_extra_1 = tslib_1.__importDefault(require("fs-extra"));
+const path_1 = tslib_1.__importDefault(require("path"));
+const events_1 = require("../analytics/events");
+const prompts_1 = require("../prompts");
+const tasks_1 = require("./apple/tasks");
+const config_1 = require("./config");
+const context_1 = require("./context");
+const errors_1 = require("./errors");
+const telemetry_1 = require("./utils/telemetry");
+/**
+ * Generate a local store configuration from the stores.
+ * Note, only App Store is supported at this time.
+ */
+async function downloadMetadataAsync(metadataCtx) {
+    const filePath = path_1.default.resolve(metadataCtx.projectDir, metadataCtx.metadataPath);
+    const fileExists = await fs_extra_1.default.pathExists(filePath);
+    if (fileExists) {
+        const overwrite = await (0, prompts_1.confirmAsync)({
+            message: `Do you want to overwrite the existing store configuration "${metadataCtx.metadataPath}"?`,
+        });
+        if (!overwrite) {
+            throw new errors_1.MetadataValidationError(`Store configuration already exists at "${filePath}"`);
+        }
+    }
+    const { app, auth } = await (0, context_1.ensureMetadataAppStoreAuthenticatedAsync)(metadataCtx);
+    const { unsubscribeTelemetry, executionId } = (0, telemetry_1.subscribeTelemetry)(events_1.MetadataEvent.APPLE_METADATA_DOWNLOAD, { app, auth });
+    const errors = [];
+    const config = (0, config_1.createAppleWriter)();
+    const tasks = (0, tasks_1.createAppleTasks)(metadataCtx);
+    const taskCtx = { app };
+    for (const task of tasks) {
+        try {
+            await task.prepareAsync({ context: taskCtx });
+        }
+        catch (error) {
+            errors.push(error);
+        }
+    }
+    for (const task of tasks) {
+        try {
+            await task.downloadAsync({ config, context: taskCtx });
+        }
+        catch (error) {
+            errors.push(error);
+        }
+    }
+    await fs_extra_1.default.writeJson(filePath, config.toSchema(), { spaces: 2 });
+    unsubscribeTelemetry();
+    if (errors.length > 0) {
+        throw new errors_1.MetadataDownloadError(errors, executionId);
+    }
+    return filePath;
+}
+exports.downloadMetadataAsync = downloadMetadataAsync;

package/build/metadata/errors.d.ts

@@ -0,0 +1,37 @@
+import type { ErrorObject } from 'ajv';
+/**
+ * Before syncing data to the ASC API, we need to validate the metadata config.
+ * This error represents unrecoverable issues before syncing that data,
+ * and should contain useful information for the user to solve before trying again.
+ */
+export declare class MetadataValidationError extends Error {
+    readonly errors?: ErrorObject[] | undefined;
+    constructor(message?: string, errors?: ErrorObject[] | undefined);
+}
+/**
+ * If a single entity failed to update, we don't block the other entities from uploading.
+ * We still attempt to update the data in the stores as much as possible.
+ * Because of that, we keep track of any errors encountered and throw this generic error.
+ * It contains that list of encountered errors to present to the user.
+ */
+export declare class MetadataUploadError extends Error {
+    readonly errors: Error[];
+    readonly executionId: string;
+    constructor(errors: Error[], executionId: string);
+}
+/**
+ * If a single entity failed to download, we don't block the other entities from downloading.
+ * We sill attempt to pull in the data from the stores as much as possible.
+ * Because of that, we keep track of any errors envountered and throw this generic error.
+ * It contains that list of encountered errors to present to the user.
+ */
+export declare class MetadataDownloadError extends Error {
+    readonly errors: Error[];
+    readonly executionId: string;
+    constructor(errors: Error[], executionId: string);
+}
+/**
+ * Handle a thrown metadata error by informing the user what went wrong.
+ * If a normal error is thrown, this method will re-throw that error to avoid consuming it.
+ */
+export declare function handleMetadataError(error: Error): void;

package/build/metadata/errors.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleMetadataError = exports.MetadataDownloadError = exports.MetadataUploadError = exports.MetadataValidationError = void 0;
+const tslib_1 = require("tslib");
+const log_1 = tslib_1.__importStar(require("../log"));
+/**
+ * Before syncing data to the ASC API, we need to validate the metadata config.
+ * This error represents unrecoverable issues before syncing that data,
+ * and should contain useful information for the user to solve before trying again.
+ */
+class MetadataValidationError extends Error {
+    constructor(message, errors) {
+        super(message !== null && message !== void 0 ? message : 'Store configuration validation failed');
+        this.errors = errors;
+    }
+}
+exports.MetadataValidationError = MetadataValidationError;
+/**
+ * If a single entity failed to update, we don't block the other entities from uploading.
+ * We still attempt to update the data in the stores as much as possible.
+ * Because of that, we keep track of any errors encountered and throw this generic error.
+ * It contains that list of encountered errors to present to the user.
+ */
+class MetadataUploadError extends Error {
+    constructor(errors, executionId) {
+        super(`Store configuration upload encountered ${errors.length === 1 ? 'an error' : `${errors.length} errors`}.`);
+        this.errors = errors;
+        this.executionId = executionId;
+    }
+}
+exports.MetadataUploadError = MetadataUploadError;
+/**
+ * If a single entity failed to download, we don't block the other entities from downloading.
+ * We sill attempt to pull in the data from the stores as much as possible.
+ * Because of that, we keep track of any errors envountered and throw this generic error.
+ * It contains that list of encountered errors to present to the user.
+ */
+class MetadataDownloadError extends Error {
+    constructor(errors, executionId) {
+        super(`Store configuration download encountered ${errors.length === 1 ? 'an error' : `${errors.length} errors`}.`);
+        this.errors = errors;
+        this.executionId = executionId;
+    }
+}
+exports.MetadataDownloadError = MetadataDownloadError;
+/**
+ * Handle a thrown metadata error by informing the user what went wrong.
+ * If a normal error is thrown, this method will re-throw that error to avoid consuming it.
+ */
+function handleMetadataError(error) {
+    var _a;
+    if (error instanceof MetadataValidationError) {
+        log_1.default.error(error.message);
+        log_1.default.log((_a = error.errors) === null || _a === void 0 ? void 0 : _a.map(err => `  - ${err.dataPath} ${err.message}`).join('\n'));
+        return;
+    }
+    if (error instanceof MetadataDownloadError || error instanceof MetadataUploadError) {
+        log_1.default.error(error.message);
+        log_1.default.log('Please check the logs for any configuration issues.');
+        log_1.default.log('If this issue persists, please open a new issue at:');
+        // TODO: add execution ID to the issue template link
+        log_1.default.log((0, log_1.link)('https://github.com/expo/eas-cli'));
+        return;
+    }
+    throw error;
+}
+exports.handleMetadataError = handleMetadataError;

package/build/metadata/upload.d.ts

@@ -0,0 +1,6 @@
+import { MetadataContext } from './context';
+/**
+ * Sync a local store configuration with the stores.
+ * Note, only App Store is supported at this time.
+ */
+export declare function uploadMetadataAsync(metadataCtx: MetadataContext): Promise<void>;

package/build/metadata/upload.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uploadMetadataAsync = void 0;
+const tslib_1 = require("tslib");
+const fs_extra_1 = tslib_1.__importDefault(require("fs-extra"));
+const path_1 = tslib_1.__importDefault(require("path"));
+const events_1 = require("../analytics/events");
+const tasks_1 = require("./apple/tasks");
+const config_1 = require("./config");
+const context_1 = require("./context");
+const errors_1 = require("./errors");
+const telemetry_1 = require("./utils/telemetry");
+/**
+ * Sync a local store configuration with the stores.
+ * Note, only App Store is supported at this time.
+ */
+async function uploadMetadataAsync(metadataCtx) {
+    const filePath = path_1.default.resolve(metadataCtx.projectDir, metadataCtx.metadataPath);
+    if (!(await fs_extra_1.default.pathExists(filePath))) {
+        throw new errors_1.MetadataValidationError(`Store configuration file not found "${filePath}"`);
+    }
+    const { app, auth } = await (0, context_1.ensureMetadataAppStoreAuthenticatedAsync)(metadataCtx);
+    const { unsubscribeTelemetry, executionId } = (0, telemetry_1.subscribeTelemetry)(events_1.MetadataEvent.APPLE_METADATA_UPLOAD, { app, auth });
+    const fileData = await fs_extra_1.default.readJson(filePath);
+    const { valid, errors: validationErrors } = (0, config_1.validateConfig)(fileData);
+    if (!valid) {
+        throw new errors_1.MetadataValidationError(`Store configuration errors found`, validationErrors);
+    }
+    const errors = [];
+    const config = (0, config_1.createAppleReader)(fileData);
+    const tasks = (0, tasks_1.createAppleTasks)(metadataCtx);
+    const taskCtx = { app };
+    for (const task of tasks) {
+        try {
+            await task.prepareAsync({ context: taskCtx });
+        }
+        catch (error) {
+            errors.push(error);
+        }
+    }
+    for (const task of tasks) {
+        try {
+            await task.uploadAsync({ config, context: taskCtx });
+        }
+        catch (error) {
+            errors.push(error);
+        }
+    }
+    unsubscribeTelemetry();
+    if (errors.length > 0) {
+        throw new errors_1.MetadataUploadError(errors, executionId);
+    }
+}
+exports.uploadMetadataAsync = uploadMetadataAsync;

package/build/metadata/utils/array.d.ts

@@ -0,0 +1 @@
+export declare function unique<T = any>(items: T[]): T[];

package/build/metadata/utils/array.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unique = void 0;
+function unique(items) {
+    const set = new Set(items);
+    return [...set];
+}
+exports.unique = unique;

package/build/metadata/utils/asc.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="@expo/apple-utils/ts-declarations/expo__app-store" />
+import { ConnectModel } from '@expo/apple-utils';
+/** Get the properties of a single App Store Connect entity */
+export declare type AttributesOf<T extends ConnectModel> = T['attributes'];

package/build/metadata/utils/asc.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/metadata/utils/date.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Remove time precision from a date to avoid potential errors with the App Store.
+ *
+ * "status": "409",
+ * "code": "ENTITY_ERROR.ATTRIBUTE.INVALID",
+ * "title": "An attribute value is invalid.",
+ * "detail": "The attribute 'earliestReleaseDate' only allows hour precision",
+ * "source": {
+ *   "pointer": "/data/attributes/earliestReleaseDate"
+ * }
+ */
+export declare function removeDatePrecision(date: any): null | Date;

package/build/metadata/utils/date.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeDatePrecision = void 0;
+/**
+ * Remove time precision from a date to avoid potential errors with the App Store.
+ *
+ * "status": "409",
+ * "code": "ENTITY_ERROR.ATTRIBUTE.INVALID",
+ * "title": "An attribute value is invalid.",
+ * "detail": "The attribute 'earliestReleaseDate' only allows hour precision",
+ * "source": {
+ *   "pointer": "/data/attributes/earliestReleaseDate"
+ * }
+ */
+function removeDatePrecision(date) {
+    if (date) {
+        try {
+            const result = new Date(date);
+            result.setMinutes(0);
+            result.setSeconds(0);
+            result.setMilliseconds(0);
+            if (!isNaN(result.getTime())) {
+                return result;
+            }
+        }
+        catch { }
+    }
+    return null;
+}
+exports.removeDatePrecision = removeDatePrecision;

package/build/metadata/utils/log.d.ts

@@ -0,0 +1,16 @@
+import { Ora } from '../../ora';
+declare type LogAsyncOptions = {
+    /** If the spinner representing the async action should be hidden, e.g. for JSON output */
+    hidden?: boolean;
+    /** The message to display when the action is pending */
+    pending: string;
+    /** The message to display when the action succeeded */
+    success: string;
+    /** The message to display when the action failed */
+    failure: string;
+};
+/**
+ * Log an asynchronous action using a spinner.
+ */
+export declare function logAsync<T>(action: (spinner?: Ora) => Promise<T>, { hidden, ...message }: LogAsyncOptions): Promise<T>;
+export {};

package/build/metadata/utils/log.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logAsync = void 0;
+const ora_1 = require("../../ora");
+/**
+ * Log an asynchronous action using a spinner.
+ */
+async function logAsync(action, { hidden, ...message }) {
+    if (hidden) {
+        return action();
+    }
+    const spinner = (0, ora_1.ora)(message.pending).start();
+    try {
+        const result = await action(spinner);
+        spinner.succeed(message.success);
+        return result;
+    }
+    catch (error) {
+        spinner.fail(message.failure);
+        throw error;
+    }
+}
+exports.logAsync = logAsync;

package/build/metadata/utils/retry.d.ts

@@ -0,0 +1,8 @@
+export declare function waitAsync(duration: number): Promise<void>;
+declare type WithRetryOptions = {
+    tries?: number;
+    delay?: number;
+    onRetry?: (triesLeft: number) => void;
+};
+export declare function retryIfNullAsync<T>(method: () => Promise<T | null>, options?: WithRetryOptions): Promise<T | null>;
+export {};

package/build/metadata/utils/retry.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.retryIfNullAsync = exports.waitAsync = void 0;
+async function waitAsync(duration) {
+    return new Promise(resolve => setTimeout(resolve, duration));
+}
+exports.waitAsync = waitAsync;
+async function retryIfNullAsync(method, options = {}) {
+    var _a;
+    let { tries = 5, delay = 1000 } = options;
+    while (tries > 0) {
+        const value = await method();
+        if (value !== null) {
+            return value;
+        }
+        tries--;
+        (_a = options.onRetry) === null || _a === void 0 ? void 0 : _a.call(options, tries);
+        await waitAsync(delay);
+    }
+    return null;
+}
+exports.retryIfNullAsync = retryIfNullAsync;

package/build/metadata/utils/telemetry.d.ts

@@ -0,0 +1,20 @@
+/// <reference types="@expo/apple-utils/ts-declarations/expo__app-store" />
+import { App, Session } from '@expo/apple-utils';
+import { MetadataEvent } from '../../analytics/events';
+export declare type TelemetryContext = {
+    app: App;
+    auth: Partial<Session.AuthState>;
+};
+/**
+ * Subscribe the telemetry to the ongoing metadata requests and responses.
+ * When providing the app and auth info, we can scrub that data from the telemetry.
+ * Returns an execution ID to group all events of a single run together, and a unsubscribe function.
+ */
+export declare function subscribeTelemetry(event: MetadataEvent, options: TelemetryContext): {
+    /** Unsubscribe the telemetry from all apple-utils events */
+    unsubscribeTelemetry: () => void;
+    /** The unique id added to all telemetry events from a single execution */
+    executionId: string;
+};
+/** Exposed for testing */
+export declare function makeDataScrubber({ app, auth }: TelemetryContext): <T>(data: T) => string;

package/build/metadata/utils/telemetry.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeDataScrubber = exports.subscribeTelemetry = void 0;
+const apple_utils_1 = require("@expo/apple-utils");
+const uuid_1 = require("uuid");
+const events_1 = require("../../analytics/events");
+/**
+ * Subscribe the telemetry to the ongoing metadata requests and responses.
+ * When providing the app and auth info, we can scrub that data from the telemetry.
+ * Returns an execution ID to group all events of a single run together, and a unsubscribe function.
+ */
+function subscribeTelemetry(event, options) {
+    const executionId = (0, uuid_1.v4)();
+    const scrubber = makeDataScrubber(options);
+    const { interceptors } = (0, apple_utils_1.getRequestClient)();
+    const responseInterceptorId = interceptors.response.use(response => {
+        events_1.Analytics.logEvent(event, {
+            executionId,
+            type: 'response',
+            phase: 'resolved',
+            method: response.request.method.toUpperCase(),
+            url: scrubber(response.request.path),
+            status: String(response.status),
+            statusText: scrubber(response.statusText),
+        });
+        return response;
+    }, (error) => {
+        var _a, _b, _c;
+        events_1.Analytics.logEvent(event, {
+            executionId,
+            type: 'response',
+            phase: 'rejected',
+            method: error.request.method.toUpperCase(),
+            url: scrubber(error.config.url),
+            error: scrubber(error.message),
+            status: String((_a = error.response) === null || _a === void 0 ? void 0 : _a.status),
+            statusText: scrubber((_b = error.response) === null || _b === void 0 ? void 0 : _b.statusText),
+            input: scrubber(error.config.data),
+            output: scrubber((_c = error.response) === null || _c === void 0 ? void 0 : _c.data),
+        });
+        throw error;
+    });
+    function unsubscribeTelemetry() {
+        interceptors.response.eject(responseInterceptorId);
+    }
+    return { unsubscribeTelemetry, executionId };
+}
+exports.subscribeTelemetry = subscribeTelemetry;
+/** Exposed for testing */
+function makeDataScrubber({ app, auth }) {
+    var _a, _b;
+    const token = getAuthTokenString(auth);
+    const patterns = {
+        APPLE_APP_ID: new RegExp(app.id, 'gi'),
+        APPLE_USERNAME: auth.username ? new RegExp(auth.username, 'gi') : null,
+        APPLE_PASSWORD: auth.password ? new RegExp(auth.password, 'gi') : null,
+        APPLE_TOKEN: token ? new RegExp(token, 'gi') : null,
+        APPLE_TEAM_ID: ((_a = auth.context) === null || _a === void 0 ? void 0 : _a.teamId) ? new RegExp(auth.context.teamId, 'gi') : null,
+        APPLE_PROVIDER_ID: ((_b = auth.context) === null || _b === void 0 ? void 0 : _b.providerId)
+            ? new RegExp(String(auth.context.providerId), 'gi')
+            : null,
+    };
+    const iterator = Object.entries(patterns);
+    return function scrubber(data) {
+        if (!data) {
+            return String(data);
+        }
+        let value = typeof data === 'object' ? JSON.stringify(data) : String(data);
+        for (const [replacement, pattern] of iterator) {
+            if (pattern) {
+                value = value.replace(pattern, `{${replacement}}`);
+            }
+        }
+        return value;
+    };
+}
+exports.makeDataScrubber = makeDataScrubber;
+function getAuthTokenString(auth) {
+    var _a;
+    if (!((_a = auth.context) === null || _a === void 0 ? void 0 : _a.token)) {
+        return null;
+    }
+    if (typeof auth.context.token === 'object') {
+        return auth.context.token.getToken();
+    }
+    return auth.context.token;
+}

package/build/project/android/applicationId.js

@@ -25,7 +25,7 @@ async function ensureApplicationIdIsDefinedForManagedProjectAsync(projectDir, ex
             moduleName: gradleUtils.DEFAULT_MODULE_NAME,
         });
     }
-    catch (err) {
+    catch {
         return await configureApplicationIdAsync(projectDir, exp);
     }
 }

package/build/project/ios/bundleIdentifier.js

@@ -21,7 +21,7 @@ async function ensureBundleIdentifierIsDefinedForManagedProjectAsync(projectDir,
     try {
         return await getBundleIdentifierAsync(projectDir, exp);
     }
-    catch (err) {
+    catch {
         return await configureBundleIdentifierAsync(projectDir, exp);
     }
 }

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

@@ -0,0 +1,8 @@
+import { JSONObject } from '@expo/json-file';
+interface Target {
+    buildConfiguration?: string;
+    targetName: string;
+}
+export declare function getManagedApplicationTargetEntitlementsAsync(projectDir: string, env: Record<string, string>): Promise<JSONObject>;
+export declare function getNativeTargetEntitlementsAsync(projectDir: string, target: Target): Promise<JSONObject | null>;
+export {};