eas-cli 18.4.0 → 18.5.0

package/build/metadata/apple/tasks/previews.js

@@ -0,0 +1,208 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PreviewsTask = void 0;
+const tslib_1 = require("tslib");
+const apple_utils_1 = require("@expo/apple-utils");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const fs_1 = tslib_1.__importDefault(require("fs"));
+const path_1 = tslib_1.__importDefault(require("path"));
+const fetch_1 = tslib_1.__importDefault(require("../../../fetch"));
+const log_1 = tslib_1.__importDefault(require("../../../log"));
+const log_2 = require("../../utils/log");
+const task_1 = require("../task");
+/**
+ * Normalize preview config to always return an object with path and optional previewFrameTimeCode.
+ */
+function normalizePreviewConfig(config) {
+    if (typeof config === 'string') {
+        return { path: config };
+    }
+    return config;
+}
+/**
+ * Task for managing App Store video previews.
+ * Downloads existing previews and uploads new ones based on store configuration.
+ */
+class PreviewsTask extends task_1.AppleTask {
+    name = () => 'video previews';
+    async prepareAsync({ context }) {
+        // Initialize the preview sets map
+        context.previewSets = new Map();
+        if (!context.versionLocales) {
+            return;
+        }
+        // Fetch preview sets for all locales in parallel
+        await Promise.all(context.versionLocales.map(async (locale) => {
+            const sets = await locale.getAppPreviewSetsAsync();
+            const previewTypeMap = new Map();
+            for (const set of sets) {
+                previewTypeMap.set(set.attributes.previewType, set);
+            }
+            context.previewSets.set(locale.attributes.locale, previewTypeMap);
+        }));
+    }
+    async downloadAsync({ config, context }) {
+        if (!context.previewSets || !context.versionLocales) {
+            return;
+        }
+        for (const locale of context.versionLocales) {
+            const localeCode = locale.attributes.locale;
+            const previewTypeMap = context.previewSets.get(localeCode);
+            if (!previewTypeMap || previewTypeMap.size === 0) {
+                continue;
+            }
+            const previews = {};
+            for (const [previewType, set] of previewTypeMap) {
+                const previewModels = set.attributes.appPreviews;
+                if (!previewModels || previewModels.length === 0) {
+                    continue;
+                }
+                // For now, we only handle the first preview per set (App Store allows up to 3)
+                // We can extend this later to support multiple previews
+                const preview = previewModels[0];
+                const relativePath = await downloadPreviewAsync(context.projectDir, localeCode, previewType, preview, 0);
+                if (relativePath) {
+                    // Include preview frame time code if available
+                    if (preview.attributes.previewFrameTimeCode) {
+                        previews[previewType] = {
+                            path: relativePath,
+                            previewFrameTimeCode: preview.attributes.previewFrameTimeCode,
+                        };
+                    }
+                    else {
+                        previews[previewType] = relativePath;
+                    }
+                }
+            }
+            if (Object.keys(previews).length > 0) {
+                config.setPreviews(localeCode, previews);
+            }
+        }
+    }
+    async uploadAsync({ config, context }) {
+        if (!context.previewSets || !context.versionLocales) {
+            log_1.default.log((0, chalk_1.default) `{dim - Skipped video previews, no version available}`);
+            return;
+        }
+        const locales = config.getLocales();
+        if (locales.length <= 0) {
+            log_1.default.log((0, chalk_1.default) `{dim - Skipped video previews, no locales configured}`);
+            return;
+        }
+        for (const localeCode of locales) {
+            const previews = config.getPreviews(localeCode);
+            if (!previews || Object.keys(previews).length === 0) {
+                continue;
+            }
+            const localization = context.versionLocales.find(l => l.attributes.locale === localeCode);
+            if (!localization) {
+                log_1.default.warn((0, chalk_1.default) `{yellow Skipping video previews for ${localeCode} - locale not found}`);
+                continue;
+            }
+            for (const [previewType, previewConfig] of Object.entries(previews)) {
+                if (!previewConfig) {
+                    continue;
+                }
+                await syncPreviewSetAsync(context.projectDir, localization, previewType, normalizePreviewConfig(previewConfig), context.previewSets.get(localeCode));
+            }
+        }
+    }
+}
+exports.PreviewsTask = PreviewsTask;
+/**
+ * Sync a preview set - upload new preview, delete old one if changed.
+ */
+async function syncPreviewSetAsync(projectDir, localization, previewType, previewConfig, existingSets) {
+    const locale = localization.attributes.locale;
+    const absolutePath = path_1.default.resolve(projectDir, previewConfig.path);
+    const fileName = path_1.default.basename(absolutePath);
+    if (!fs_1.default.existsSync(absolutePath)) {
+        log_1.default.warn((0, chalk_1.default) `{yellow Video preview not found: ${absolutePath}}`);
+        return;
+    }
+    // Get or create the preview set
+    let previewSet = existingSets?.get(previewType);
+    if (!previewSet) {
+        previewSet = await (0, log_2.logAsync)(() => localization.createAppPreviewSetAsync({
+            previewType,
+        }), {
+            pending: `Creating preview set for ${chalk_1.default.bold(previewType)} (${locale})...`,
+            success: `Created preview set for ${chalk_1.default.bold(previewType)} (${locale})`,
+            failure: `Failed creating preview set for ${chalk_1.default.bold(previewType)} (${locale})`,
+        });
+    }
+    const existingPreviews = previewSet.attributes.appPreviews || [];
+    // Check if we need to update (different filename, size, or no existing preview)
+    const existingPreview = existingPreviews.find(p => p.attributes.fileName === fileName);
+    const localSize = fs_1.default.statSync(absolutePath).size;
+    if (existingPreview &&
+        existingPreview.isComplete() &&
+        existingPreview.attributes.fileSize === localSize) {
+        // Preview with same filename exists, check if we need to update preview frame time code
+        if (previewConfig.previewFrameTimeCode &&
+            existingPreview.attributes.previewFrameTimeCode !== previewConfig.previewFrameTimeCode) {
+            await (0, log_2.logAsync)(() => existingPreview.updateAsync({
+                previewFrameTimeCode: previewConfig.previewFrameTimeCode,
+            }), {
+                pending: `Updating preview frame time code for ${chalk_1.default.bold(fileName)} (${locale})...`,
+                success: `Updated preview frame time code for ${chalk_1.default.bold(fileName)} (${locale})`,
+                failure: `Failed updating preview frame time code for ${chalk_1.default.bold(fileName)} (${locale})`,
+            });
+        }
+        log_1.default.log((0, chalk_1.default) `{dim Preview ${fileName} already exists, skipping upload}`);
+        return;
+    }
+    // Delete existing previews that don't match
+    for (const preview of existingPreviews) {
+        if (preview.attributes.fileName !== fileName) {
+            await (0, log_2.logAsync)(() => preview.deleteAsync(), {
+                pending: `Deleting old preview ${chalk_1.default.bold(preview.attributes.fileName)} (${locale})...`,
+                success: `Deleted old preview ${chalk_1.default.bold(preview.attributes.fileName)} (${locale})`,
+                failure: `Failed deleting old preview ${chalk_1.default.bold(preview.attributes.fileName)} (${locale})`,
+            });
+        }
+    }
+    // Upload new preview
+    await (0, log_2.logAsync)(() => apple_utils_1.AppPreview.uploadAsync(localization.context, {
+        id: previewSet.id,
+        filePath: absolutePath,
+        waitForProcessing: true,
+        previewFrameTimeCode: previewConfig.previewFrameTimeCode,
+    }), {
+        pending: `Uploading video preview ${chalk_1.default.bold(fileName)} (${locale})...`,
+        success: `Uploaded video preview ${chalk_1.default.bold(fileName)} (${locale})`,
+        failure: `Failed uploading video preview ${chalk_1.default.bold(fileName)} (${locale})`,
+    });
+}
+/**
+ * Download a video preview to the local filesystem.
+ * Returns the relative path to the downloaded file.
+ */
+async function downloadPreviewAsync(projectDir, locale, previewType, preview, index) {
+    const videoUrl = preview.getVideoUrl();
+    if (!videoUrl) {
+        log_1.default.warn((0, chalk_1.default) `{yellow Could not get download URL for preview ${preview.attributes.fileName}}`);
+        return null;
+    }
+    // Create directory structure: store/apple/preview/{locale}/{previewType}/
+    const previewsDir = path_1.default.join(projectDir, 'store', 'apple', 'preview', locale, previewType);
+    await fs_1.default.promises.mkdir(previewsDir, { recursive: true });
+    // Use original filename for matching during sync
+    const fileName = preview.attributes.fileName || `${String(index + 1).padStart(2, '0')}.mp4`;
+    const outputPath = path_1.default.join(previewsDir, fileName);
+    const relativePath = path_1.default.relative(projectDir, outputPath);
+    try {
+        const response = await (0, fetch_1.default)(videoUrl);
+        if (!response.ok) {
+            throw new Error(`HTTP ${response.status}`);
+        }
+        const buffer = await response.buffer();
+        await fs_1.default.promises.writeFile(outputPath, buffer);
+        log_1.default.log((0, chalk_1.default) `{dim Downloaded video preview: ${relativePath}}`);
+        return relativePath;
+    }
+    catch (error) {
+        log_1.default.warn((0, chalk_1.default) `{yellow Failed to download video preview ${fileName}: ${error.message}}`);
+        return null;
+    }
+}

package/build/metadata/apple/tasks/screenshots.d.ts

@@ -0,0 +1,18 @@
+import { AppScreenshotSet, ScreenshotDisplayType } from '@expo/apple-utils';
+import { AppleTask, TaskDownloadOptions, TaskPrepareOptions, TaskUploadOptions } from '../task';
+/** Locale -> ScreenshotDisplayType -> AppScreenshotSet */
+export type ScreenshotSetsMap = Map<string, Map<ScreenshotDisplayType, AppScreenshotSet>>;
+export type ScreenshotsData = {
+    /** Map of locales to their screenshot sets */
+    screenshotSets: ScreenshotSetsMap;
+};
+/**
+ * Task for managing App Store screenshots.
+ * Downloads existing screenshots and uploads new ones based on store configuration.
+ */
+export declare class ScreenshotsTask extends AppleTask {
+    name: () => string;
+    prepareAsync({ context }: TaskPrepareOptions): Promise<void>;
+    downloadAsync({ config, context }: TaskDownloadOptions): Promise<void>;
+    uploadAsync({ config, context }: TaskUploadOptions): Promise<void>;
+}

package/build/metadata/apple/tasks/screenshots.js

@@ -0,0 +1,224 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScreenshotsTask = void 0;
+const tslib_1 = require("tslib");
+const apple_utils_1 = require("@expo/apple-utils");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const fs_1 = tslib_1.__importDefault(require("fs"));
+const path_1 = tslib_1.__importDefault(require("path"));
+const fetch_1 = tslib_1.__importDefault(require("../../../fetch"));
+const log_1 = tslib_1.__importDefault(require("../../../log"));
+const log_2 = require("../../utils/log");
+const task_1 = require("../task");
+/**
+ * Task for managing App Store screenshots.
+ * Downloads existing screenshots and uploads new ones based on store configuration.
+ */
+class ScreenshotsTask extends task_1.AppleTask {
+    name = () => 'screenshots';
+    async prepareAsync({ context }) {
+        // Initialize the screenshot sets map
+        context.screenshotSets = new Map();
+        if (!context.versionLocales) {
+            return;
+        }
+        // Fetch screenshot sets for all locales in parallel
+        await Promise.all(context.versionLocales.map(async (locale) => {
+            const sets = await locale.getAppScreenshotSetsAsync();
+            const displayTypeMap = new Map();
+            for (const set of sets) {
+                displayTypeMap.set(set.attributes.screenshotDisplayType, set);
+            }
+            context.screenshotSets.set(locale.attributes.locale, displayTypeMap);
+        }));
+    }
+    async downloadAsync({ config, context }) {
+        if (!context.screenshotSets || !context.versionLocales) {
+            return;
+        }
+        for (const locale of context.versionLocales) {
+            const localeCode = locale.attributes.locale;
+            const displayTypeMap = context.screenshotSets.get(localeCode);
+            if (!displayTypeMap || displayTypeMap.size === 0) {
+                continue;
+            }
+            const screenshots = {};
+            for (const [displayType, set] of displayTypeMap) {
+                const screenshotModels = set.attributes.appScreenshots;
+                if (!screenshotModels || screenshotModels.length === 0) {
+                    continue;
+                }
+                // Download screenshots and save to local filesystem
+                const paths = [];
+                for (let i = 0; i < screenshotModels.length; i++) {
+                    const screenshot = screenshotModels[i];
+                    const relativePath = await downloadScreenshotAsync(context.projectDir, localeCode, displayType, screenshot, i);
+                    if (relativePath) {
+                        paths.push(relativePath);
+                    }
+                }
+                if (paths.length > 0) {
+                    screenshots[displayType] = paths;
+                }
+            }
+            if (Object.keys(screenshots).length > 0) {
+                config.setScreenshots(localeCode, screenshots);
+            }
+        }
+    }
+    async uploadAsync({ config, context }) {
+        if (!context.screenshotSets || !context.versionLocales) {
+            log_1.default.log((0, chalk_1.default) `{dim - Skipped screenshots, no version available}`);
+            return;
+        }
+        const locales = config.getLocales();
+        if (locales.length <= 0) {
+            log_1.default.log((0, chalk_1.default) `{dim - Skipped screenshots, no locales configured}`);
+            return;
+        }
+        for (const localeCode of locales) {
+            const screenshots = config.getScreenshots(localeCode);
+            if (!screenshots || Object.keys(screenshots).length === 0) {
+                continue;
+            }
+            const localization = context.versionLocales.find(l => l.attributes.locale === localeCode);
+            if (!localization) {
+                log_1.default.warn((0, chalk_1.default) `{yellow Skipping screenshots for ${localeCode} - locale not found}`);
+                continue;
+            }
+            for (const [displayType, paths] of Object.entries(screenshots)) {
+                if (!paths || paths.length === 0) {
+                    continue;
+                }
+                await syncScreenshotSetAsync(context.projectDir, localization, displayType, paths, context.screenshotSets.get(localeCode));
+            }
+        }
+    }
+}
+exports.ScreenshotsTask = ScreenshotsTask;
+/**
+ * Sync a screenshot set - upload new screenshots, delete removed ones, reorder if needed.
+ */
+async function syncScreenshotSetAsync(projectDir, localization, displayType, paths, existingSets) {
+    const locale = localization.attributes.locale;
+    // Get or create the screenshot set
+    let screenshotSet = existingSets?.get(displayType);
+    if (!screenshotSet) {
+        screenshotSet = await (0, log_2.logAsync)(() => localization.createAppScreenshotSetAsync({
+            screenshotDisplayType: displayType,
+        }), {
+            pending: `Creating screenshot set for ${chalk_1.default.bold(displayType)} (${locale})...`,
+            success: `Created screenshot set for ${chalk_1.default.bold(displayType)} (${locale})`,
+            failure: `Failed creating screenshot set for ${chalk_1.default.bold(displayType)} (${locale})`,
+        });
+    }
+    const existingScreenshots = screenshotSet.attributes.appScreenshots || [];
+    // Build a map of existing screenshots by filename for comparison
+    const existingByFilename = new Map();
+    for (const screenshot of existingScreenshots) {
+        existingByFilename.set(screenshot.attributes.fileName, screenshot);
+    }
+    // Track which screenshots to keep, upload, and delete
+    const screenshotIdsToKeep = [];
+    const pathsToUpload = [];
+    for (const relativePath of paths) {
+        const absolutePath = path_1.default.resolve(projectDir, relativePath);
+        const fileName = path_1.default.basename(absolutePath);
+        // Check if screenshot already exists with same name and file size
+        const existing = existingByFilename.get(fileName);
+        const localSize = fs_1.default.existsSync(absolutePath) ? fs_1.default.statSync(absolutePath).size : null;
+        if (existing &&
+            existing.isComplete() &&
+            (localSize === null || existing.attributes.fileSize === localSize)) {
+            screenshotIdsToKeep.push(existing.id);
+            existingByFilename.delete(fileName);
+        }
+        else {
+            pathsToUpload.push(absolutePath);
+        }
+    }
+    // Delete screenshots that are no longer in config
+    for (const screenshot of existingByFilename.values()) {
+        await (0, log_2.logAsync)(() => screenshot.deleteAsync(), {
+            pending: `Deleting screenshot ${chalk_1.default.bold(screenshot.attributes.fileName)} (${locale})...`,
+            success: `Deleted screenshot ${chalk_1.default.bold(screenshot.attributes.fileName)} (${locale})`,
+            failure: `Failed deleting screenshot ${chalk_1.default.bold(screenshot.attributes.fileName)} (${locale})`,
+        });
+    }
+    // Upload new screenshots
+    for (const absolutePath of pathsToUpload) {
+        const fileName = path_1.default.basename(absolutePath);
+        if (!fs_1.default.existsSync(absolutePath)) {
+            log_1.default.warn((0, chalk_1.default) `{yellow Screenshot not found: ${absolutePath}}`);
+            continue;
+        }
+        const newScreenshot = await (0, log_2.logAsync)(() => apple_utils_1.AppScreenshot.uploadAsync(localization.context, {
+            id: screenshotSet.id,
+            filePath: absolutePath,
+            waitForProcessing: true,
+        }), {
+            pending: `Uploading screenshot ${chalk_1.default.bold(fileName)} (${locale})...`,
+            success: `Uploaded screenshot ${chalk_1.default.bold(fileName)} (${locale})`,
+            failure: `Failed uploading screenshot ${chalk_1.default.bold(fileName)} (${locale})`,
+        });
+        screenshotIdsToKeep.push(newScreenshot.id);
+    }
+    // Reorder screenshots to match config order
+    if (screenshotIdsToKeep.length > 0) {
+        const refreshedSet = await apple_utils_1.AppScreenshotSet.infoAsync(localization.context, {
+            id: screenshotSet.id,
+        });
+        const refreshedScreenshots = refreshedSet.attributes.appScreenshots || [];
+        const screenshotsByFilename = new Map();
+        for (const s of refreshedScreenshots) {
+            screenshotsByFilename.set(s.attributes.fileName, s);
+        }
+        // Build the desired order based on config paths
+        const orderedIds = [];
+        for (const relativePath of paths) {
+            const fileName = path_1.default.basename(relativePath);
+            const screenshot = screenshotsByFilename.get(fileName);
+            if (screenshot) {
+                orderedIds.push(screenshot.id);
+            }
+        }
+        // Only call reorder if the order actually differs from current
+        const currentIds = refreshedScreenshots.map(s => s.id);
+        if (orderedIds.length > 0 &&
+            (orderedIds.length !== currentIds.length || orderedIds.some((id, i) => id !== currentIds[i]))) {
+            await screenshotSet.reorderScreenshotsAsync({ appScreenshots: orderedIds });
+        }
+    }
+}
+/**
+ * Download a screenshot to the local filesystem.
+ * Returns the relative path to the downloaded file.
+ */
+async function downloadScreenshotAsync(projectDir, locale, displayType, screenshot, index) {
+    const imageUrl = screenshot.getImageAssetUrl({ type: 'png' });
+    if (!imageUrl) {
+        log_1.default.warn((0, chalk_1.default) `{yellow Could not get download URL for screenshot ${screenshot.attributes.fileName}}`);
+        return null;
+    }
+    // Create directory structure: store/apple/screenshot/{locale}/{displayType}/
+    const screenshotsDir = path_1.default.join(projectDir, 'store', 'apple', 'screenshot', locale, displayType);
+    await fs_1.default.promises.mkdir(screenshotsDir, { recursive: true });
+    // Use original filename for matching during sync
+    const fileName = screenshot.attributes.fileName || `${String(index + 1).padStart(2, '0')}.png`;
+    const outputPath = path_1.default.join(screenshotsDir, fileName);
+    const relativePath = path_1.default.relative(projectDir, outputPath);
+    try {
+        const response = await (0, fetch_1.default)(imageUrl);
+        if (!response.ok) {
+            throw new Error(`HTTP ${response.status}`);
+        }
+        const buffer = await response.buffer();
+        await fs_1.default.promises.writeFile(outputPath, buffer);
+        log_1.default.log((0, chalk_1.default) `{dim Downloaded screenshot: ${relativePath}}`);
+        return relativePath;
+    }
+    catch (error) {
+        log_1.default.warn((0, chalk_1.default) `{yellow Failed to download screenshot ${fileName}: ${error.message}}`);
+        return null;
+    }
+}

package/build/metadata/apple/types.d.ts

@@ -1,5 +1,33 @@
-import type { AgeRatingDeclarationProps } from '@expo/apple-utils';
+import type { AgeRatingDeclarationProps, PreviewType, ScreenshotDisplayType } from '@expo/apple-utils';
 export type AppleLocale = string;
+/** Screenshot display type enum values from App Store Connect API */
+export type AppleScreenshotDisplayType = `${ScreenshotDisplayType}`;
+/** Preview display type enum values from App Store Connect API */
+export type ApplePreviewType = `${PreviewType}`;
+/**
+ * Screenshots organized by display type.
+ * Key is the display type (e.g., 'APP_IPHONE_67'), value is array of file paths.
+ * @example { "APP_IPHONE_67": ["./screenshots/home.png", "./screenshots/profile.png"] }
+ */
+export type AppleScreenshots = Partial<Record<AppleScreenshotDisplayType, string[]>>;
+/**
+ * Video preview configuration - either a simple path string or an object with options.
+ * @example "./previews/demo.mp4"
+ * @example { path: "./previews/demo.mp4", previewFrameTimeCode: "00:05:00" }
+ */
+export type ApplePreviewConfig = string | {
+    /** Video file path (relative to project root) */
+    path: string;
+    /** Optional preview frame time code (e.g., '00:05:00' for 5 seconds) */
+    previewFrameTimeCode?: string;
+};
+/**
+ * Video previews organized by display type.
+ * Key is the display type (e.g., 'IPHONE_67'), value is the preview config.
+ * @example { "IPHONE_67": "./previews/demo.mp4" }
+ * @example { "IPHONE_67": { path: "./previews/demo.mp4", previewFrameTimeCode: "00:05:00" } }
+ */
+export type ApplePreviews = Partial<Record<ApplePreviewType, ApplePreviewConfig>>;
 export interface AppleMetadata {
     version?: string;
     copyright?: string;
@@ -7,6 +35,7 @@ export interface AppleMetadata {
     categories?: AppleCategory;
     release?: AppleRelease;
     advisory?: AppleAdvisory;
+    /** @deprecated Use screenshots/previews in AppleInfo instead */
     preview?: Record<string, string[]>;
     review?: AppleReview;
 }
@@ -30,6 +59,10 @@ export interface AppleInfo {
     privacyPolicyText?: string;
     privacyChoicesUrl?: string;
     supportUrl?: string;
+    /** Screenshots for this locale, organized by display type */
+    screenshots?: AppleScreenshots;
+    /** Video previews for this locale, organized by display type */
+    previews?: ApplePreviews;
 }
 export interface AppleReview {
     firstName: string;

package/build/metadata/auth.d.ts

@@ -1,6 +1,7 @@
 import { App, Session } from '@expo/apple-utils';
 import { ExpoConfig } from '@expo/config';
 import { SubmitProfile } from '@expo/eas-json';
+import { ExpoGraphqlClient } from '../commandUtils/context/contextUtils/createGraphqlClient';
 import { CredentialsContext } from '../credentials/context';
 export type MetadataAppStoreAuthentication = {
     /** The root entity of the App store */
@@ -11,10 +12,19 @@ export type MetadataAppStoreAuthentication = {
 /**
  * To start syncing ASC entities, we need access to the apple utils App instance.
  * This resolves both the authentication and that App instance.
+ *
+ * Resolution order for authentication:
+ * 1. ASC API key from environment variables (EXPO_ASC_API_KEY_PATH, etc.)
+ * 2. ASC API key from submit profile (ascApiKeyPath, etc. in eas.json)
+ * 3. ASC API key from EAS credentials service
+ * 4. Interactive cookie auth (only when not in non-interactive mode)
  */
-export declare function getAppStoreAuthAsync({ projectDir, profile, exp, credentialsCtx, }: {
+export declare function getAppStoreAuthAsync({ projectDir, profile, exp, credentialsCtx, nonInteractive, graphqlClient, projectId, }: {
     projectDir: string;
     profile: SubmitProfile;
     exp: ExpoConfig;
     credentialsCtx: CredentialsContext;
+    nonInteractive: boolean;
+    graphqlClient: ExpoGraphqlClient;
+    projectId: string;
 }): Promise<MetadataAppStoreAuthentication>;

package/build/metadata/auth.js

@@ -4,8 +4,14 @@ exports.getAppStoreAuthAsync = getAppStoreAuthAsync;
 const tslib_1 = require("tslib");
 const apple_utils_1 = require("@expo/apple-utils");
 const assert_1 = tslib_1.__importDefault(require("assert"));
+const fs_1 = tslib_1.__importDefault(require("fs"));
 const authenticate_1 = require("../credentials/ios/appstore/authenticate");
+const authenticateTypes_1 = require("../credentials/ios/appstore/authenticateTypes");
+const resolveCredentials_1 = require("../credentials/ios/appstore/resolveCredentials");
+const AppStoreConnectApiKeyQuery_1 = require("../graphql/queries/AppStoreConnectApiKeyQuery");
+const log_1 = tslib_1.__importDefault(require("../log"));
 const bundleIdentifier_1 = require("../project/ios/bundleIdentifier");
+const projectUtils_1 = require("../project/projectUtils");
 /**
  * Resolve the bundle identifier from the selected submit profile.
  * This bundle identifier is used as target for the metadata submission.
@@ -16,15 +22,103 @@ async function resolveAppStoreBundleIdentifierAsync(projectDir, profile, exp, vc
     }
     return await (0, bundleIdentifier_1.getBundleIdentifierAsync)(projectDir, exp, vcsClient);
 }
+/**
+ * Try to resolve an ASC API key from the submit profile or EAS credentials service.
+ * Returns null if no key is available from these sources.
+ */
+async function tryResolveAscApiKeyAsync({ profile, graphqlClient, projectId, exp, bundleId, }) {
+    // 1. Check submit profile for ASC API key fields
+    if ('ascApiKeyPath' in profile && 'ascApiKeyIssuerId' in profile && 'ascApiKeyId' in profile) {
+        const { ascApiKeyPath, ascApiKeyIssuerId, ascApiKeyId } = profile;
+        if (ascApiKeyPath && ascApiKeyIssuerId && ascApiKeyId) {
+            const keyP8 = await fs_1.default.promises.readFile(ascApiKeyPath, 'utf-8');
+            // Also try to get teamId from the profile if available
+            const teamId = 'appleTeamId' in profile ? profile.appleTeamId : undefined;
+            return {
+                ascApiKey: { keyP8, keyId: ascApiKeyId, issuerId: ascApiKeyIssuerId },
+                teamId,
+            };
+        }
+    }
+    // 2. Look up stored credentials via EAS credentials service
+    try {
+        const account = await (0, projectUtils_1.getOwnerAccountForProjectIdAsync)(graphqlClient, projectId);
+        const appLookupParams = {
+            account,
+            projectName: exp.slug,
+            bundleIdentifier: bundleId,
+        };
+        // Import dynamically to avoid circular dependency issues
+        const { getAscApiKeyForAppSubmissionsAsync } = await Promise.resolve().then(() => tslib_1.__importStar(require('../credentials/ios/api/GraphqlClient')));
+        const ascKeyFragment = await getAscApiKeyForAppSubmissionsAsync(graphqlClient, appLookupParams);
+        if (ascKeyFragment) {
+            log_1.default.log('Using App Store Connect API Key from EAS credentials service.');
+            const fullKey = await AppStoreConnectApiKeyQuery_1.AppStoreConnectApiKeyQuery.getByIdAsync(graphqlClient, ascKeyFragment.id);
+            return {
+                ascApiKey: {
+                    keyP8: fullKey.keyP8,
+                    keyId: fullKey.keyIdentifier,
+                    issuerId: fullKey.issuerIdentifier,
+                },
+                teamId: ascKeyFragment.appleTeam?.appleTeamIdentifier,
+                teamName: ascKeyFragment.appleTeam?.appleTeamName ?? undefined,
+            };
+        }
+    }
+    catch (error) {
+        // If we can't look up credentials, that's fine — we'll fall back
+        log_1.default.warn(`Could not look up stored ASC API key: ${error.message}`);
+    }
+    return null;
+}
 /**
  * To start syncing ASC entities, we need access to the apple utils App instance.
  * This resolves both the authentication and that App instance.
+ *
+ * Resolution order for authentication:
+ * 1. ASC API key from environment variables (EXPO_ASC_API_KEY_PATH, etc.)
+ * 2. ASC API key from submit profile (ascApiKeyPath, etc. in eas.json)
+ * 3. ASC API key from EAS credentials service
+ * 4. Interactive cookie auth (only when not in non-interactive mode)
  */
-async function getAppStoreAuthAsync({ projectDir, profile, exp, credentialsCtx, }) {
+async function getAppStoreAuthAsync({ projectDir, profile, exp, credentialsCtx, nonInteractive, graphqlClient, projectId, }) {
     const bundleId = await resolveAppStoreBundleIdentifierAsync(projectDir, profile, exp, credentialsCtx.vcsClient);
+    // Try to resolve an ASC API key from profile or credentials service
+    const resolvedKey = await tryResolveAscApiKeyAsync({
+        profile,
+        graphqlClient,
+        projectId,
+        exp,
+        bundleId,
+    });
+    if (resolvedKey || (0, resolveCredentials_1.hasAscEnvVars)()) {
+        const authOptions = {
+            mode: authenticateTypes_1.AuthenticationMode.API_KEY,
+            ...(resolvedKey
+                ? {
+                    ascApiKey: resolvedKey.ascApiKey,
+                    teamId: resolvedKey.teamId,
+                    teamName: resolvedKey.teamName,
+                    // Default to COMPANY_OR_ORGANIZATION to avoid prompting for team type
+                    teamType: authenticateTypes_1.AppleTeamType.COMPANY_OR_ORGANIZATION,
+                }
+                : {}),
+        };
+        const authCtx = await credentialsCtx.appStore.ensureAuthenticatedAsync(authOptions);
+        (0, assert_1.default)(authCtx.authState, 'Failed to authenticate with App Store Connect');
+        const app = await apple_utils_1.App.findAsync((0, authenticate_1.getRequestContext)(authCtx), { bundleId });
+        (0, assert_1.default)(app, `Failed to load app "${bundleId}" from App Store Connect`);
+        return { app, auth: authCtx.authState };
+    }
+    if (nonInteractive) {
+        throw new Error('No App Store Connect API Key found. In non-interactive mode, provide one via:\n' +
+            '  - Environment variables: EXPO_ASC_API_KEY_PATH, EXPO_ASC_KEY_ID, EXPO_ASC_ISSUER_ID\n' +
+            '  - eas.json submit profile: ascApiKeyPath, ascApiKeyId, ascApiKeyIssuerId\n' +
+            '  - EAS credentials service: run `eas credentials` to set up an API key');
+    }
+    // Fall back to interactive cookie auth
     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 });
     (0, assert_1.default)(app, `Failed to load app "${bundleId}" from App Store Connect`);
     return { app, auth: authCtx.authState };