@expo/build-tools 18.0.2 → 18.1.0

package/dist/customBuildContext.d.ts

@@ -1,6 +1,7 @@
 import { BuildJob, Env, Job, Metadata, StaticJobInterpolationContext } from '@expo/eas-build-job';
 import { bunyan } from '@expo/logger';
 import { BuildRuntimePlatform, ExternalBuildContextProvider } from '@expo/steps';
+import { Client } from '@urql/core';
 import { ArtifactToUpload, BuildContext } from './context';
 export interface BuilderRuntimeApi {
     uploadArtifact: (spec: {
@@ -20,6 +21,7 @@ export declare class CustomBuildContext<TJob extends Job = Job> implements Exter
      */
     readonly startTime: Date;
     readonly logger: bunyan;
+    readonly graphqlClient: Client;
     readonly runtimeApi: BuilderRuntimeApi;
     job: TJob;
     metadata?: Metadata;

package/dist/customBuildContext.js

@@ -34,6 +34,7 @@ class CustomBuildContext {
      */
     startTime;
     logger;
+    graphqlClient;
     runtimeApi;
     job;
     metadata;
@@ -43,6 +44,7 @@ class CustomBuildContext {
         this.job = buildCtx.job;
         this.metadata = buildCtx.metadata;
         this.logger = buildCtx.logger.child({ phase: eas_build_job_1.BuildPhase.CUSTOM });
+        this.graphqlClient = buildCtx.graphqlClient;
         this.projectSourceDirectory = path_1.default.join(buildCtx.workingdir, 'temporary-custom-build');
         this.projectTargetDirectory = path_1.default.join(buildCtx.workingdir, 'build');
         this.defaultWorkingDirectory = buildCtx.getReactNativeProjectDirectory();

package/dist/steps/easFunctions.js

@@ -22,6 +22,7 @@ const internalMaestroTest_1 = require("./functions/internalMaestroTest");
 const prebuild_1 = require("./functions/prebuild");
 const readIpaInfo_1 = require("./functions/readIpaInfo");
 const repack_1 = require("./functions/repack");
+const reportMaestroTestResults_1 = require("./functions/reportMaestroTestResults");
 const resolveAppleTeamIdFromCredentials_1 = require("./functions/resolveAppleTeamIdFromCredentials");
 const resolveBuildConfig_1 = require("./functions/resolveBuildConfig");
 const restoreBuildCache_1 = require("./functions/restoreBuildCache");
@@ -73,6 +74,7 @@ function getEasFunctions(ctx) {
         (0, createSubmissionEntity_1.createSubmissionEntityFunction)(),
         (0, uploadToAsc_1.createUploadToAscBuildFunction)(),
         (0, internalMaestroTest_1.createInternalEasMaestroTestFunction)(ctx),
+        (0, reportMaestroTestResults_1.createReportMaestroTestResultsFunction)(ctx),
     ];
     if (ctx.hasBuildJob()) {
         functions.push(...[

package/dist/steps/functions/internalMaestroTest.js

@@ -74,6 +74,10 @@ function createInternalEasMaestroTestFunction(ctx) {
                 id: 'test_reports_artifact_id',
                 required: false,
             }),
+            steps_1.BuildStepOutput.createProvider({
+                id: 'junit_report_directory',
+                required: false,
+            }),
         ],
         fn: async (stepCtx, { inputs: _inputs, env, outputs }) => {
             // inputs come in form of { value: unknown }. Here we parse them into a typed and validated object.
@@ -293,6 +297,9 @@ function createInternalEasMaestroTestFunction(ctx) {
                     stepCtx.logger.error({ err }, 'Failed to upload reports.');
                 }
             }
+            if (output_format === 'junit') {
+                outputs.junit_report_directory.set(maestroReportsDir);
+            }
             const generatedDeviceLogs = await node_fs_1.default.promises.readdir(deviceLogsDir);
             if (generatedDeviceLogs.length === 0) {
                 stepCtx.logger.warn('No device logs were successfully collected.');

package/dist/steps/functions/maestroResultParser.d.ts

@@ -0,0 +1,42 @@
+import { z } from 'zod';
+export interface MaestroFlowResult {
+    name: string;
+    path: string;
+    status: 'passed' | 'failed';
+    errorMessage: string | null;
+    duration: number;
+    retryCount: number;
+    tags: string[];
+    properties: Record<string, string>;
+}
+export declare function extractFlowKey(filename: string, prefix: string): string | null;
+export interface JUnitTestCaseResult {
+    name: string;
+    status: 'passed' | 'failed';
+    duration: number;
+    errorMessage: string | null;
+    tags: string[];
+    properties: Record<string, string>;
+}
+export declare function parseJUnitTestCases(junitDirectory: string): Promise<JUnitTestCaseResult[]>;
+declare const FlowMetadataFileSchema: z.ZodObject<{
+    flow_name: z.ZodString;
+    flow_file_path: z.ZodString;
+}, z.core.$strip>;
+type FlowMetadata = z.output<typeof FlowMetadataFileSchema>;
+/**
+ * Parses an `ai-*.json` file produced by Maestro's TestDebugReporter.
+ *
+ * The file contains:
+ * - `flow_name`: derived from the YAML `config.name` field if present, otherwise
+ *   the flow filename without extension.
+ *   See: https://github.com/mobile-dev-inc/Maestro/blob/c0e95fd/maestro-cli/src/main/java/maestro/cli/runner/TestRunner.kt#L70
+ * - `flow_file_path`: absolute path to the original flow YAML file.
+ * - `outputs`: screenshot defect data (unused here).
+ *
+ * Filename format: `ai-(flowName).json` where `/` in flowName is replaced with `_`.
+ * See: https://github.com/mobile-dev-inc/Maestro/blob/c0e95fd/maestro-cli/src/main/java/maestro/cli/report/TestDebugReporter.kt#L67
+ */
+export declare function parseFlowMetadata(filePath: string): Promise<FlowMetadata | null>;
+export declare function parseMaestroResults(junitDirectory: string, testsDirectory: string, projectRoot: string): Promise<MaestroFlowResult[]>;
+export {};

package/dist/steps/functions/maestroResultParser.js

@@ -0,0 +1,215 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractFlowKey = extractFlowKey;
+exports.parseJUnitTestCases = parseJUnitTestCases;
+exports.parseFlowMetadata = parseFlowMetadata;
+exports.parseMaestroResults = parseMaestroResults;
+const fast_xml_parser_1 = require("fast-xml-parser");
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const zod_1 = require("zod");
+// Maestro's TestDebugReporter creates timestamped directories, e.g. "2024-06-15_143022"
+const TIMESTAMP_DIR_PATTERN = /^\d{4}-\d{2}-\d{2}_\d{6}$/;
+function extractFlowKey(filename, prefix) {
+    const match = filename.match(new RegExp(`^${prefix}-(.+)\\.json$`));
+    return match?.[1] ?? null;
+}
+const xmlParser = new fast_xml_parser_1.XMLParser({
+    ignoreAttributes: false,
+    attributeNamePrefix: '@_',
+    // Ensure single-element arrays are always arrays
+    isArray: name => ['testsuite', 'testcase', 'property'].includes(name),
+});
+async function parseJUnitTestCases(junitDirectory) {
+    let entries;
+    try {
+        entries = await promises_1.default.readdir(junitDirectory);
+    }
+    catch {
+        return [];
+    }
+    const xmlFiles = entries.filter(f => f.endsWith('.xml'));
+    if (xmlFiles.length === 0) {
+        return [];
+    }
+    const results = [];
+    for (const xmlFile of xmlFiles) {
+        try {
+            const content = await promises_1.default.readFile(path_1.default.join(junitDirectory, xmlFile), 'utf-8');
+            const parsed = xmlParser.parse(content);
+            const testsuites = parsed?.testsuites?.testsuite;
+            if (!Array.isArray(testsuites)) {
+                continue;
+            }
+            for (const suite of testsuites) {
+                const testcases = suite?.testcase;
+                if (!Array.isArray(testcases)) {
+                    continue;
+                }
+                for (const tc of testcases) {
+                    const name = tc['@_name'];
+                    if (!name) {
+                        continue;
+                    }
+                    const timeStr = tc['@_time'];
+                    const timeSeconds = timeStr ? parseFloat(timeStr) : 0;
+                    const duration = Number.isFinite(timeSeconds) ? Math.round(timeSeconds * 1000) : 0;
+                    // Use @_status as primary indicator (more robust than checking <failure> presence)
+                    const status = tc['@_status'] === 'SUCCESS' ? 'passed' : 'failed';
+                    // Extract error message from <failure> or <error> elements
+                    const failureText = tc.failure != null
+                        ? typeof tc.failure === 'string'
+                            ? tc.failure
+                            : (tc.failure?.['#text'] ?? null)
+                        : null;
+                    const errorText = tc.error != null
+                        ? typeof tc.error === 'string'
+                            ? tc.error
+                            : (tc.error?.['#text'] ?? null)
+                        : null;
+                    const errorMessage = failureText ?? errorText ?? null;
+                    // Extract properties
+                    const rawProperties = tc.properties?.property ?? [];
+                    const properties = {};
+                    for (const prop of rawProperties) {
+                        const propName = prop['@_name'];
+                        const value = prop['@_value'];
+                        if (typeof propName !== 'string' || typeof value !== 'string') {
+                            continue;
+                        }
+                        properties[propName] = value;
+                    }
+                    // Extract tags from "tags" property (Maestro 2.2.0+, comma-separated)
+                    const tagsValue = properties['tags'];
+                    const tags = tagsValue
+                        ? tagsValue
+                            .split(',')
+                            .map(t => t.trim())
+                            .filter(Boolean)
+                        : [];
+                    delete properties['tags'];
+                    results.push({ name, status, duration, errorMessage, tags, properties });
+                }
+            }
+        }
+        catch {
+            // Skip malformed XML files
+            continue;
+        }
+    }
+    return results;
+}
+const FlowMetadataFileSchema = zod_1.z.object({
+    flow_name: zod_1.z.string(),
+    flow_file_path: zod_1.z.string(),
+});
+/**
+ * Parses an `ai-*.json` file produced by Maestro's TestDebugReporter.
+ *
+ * The file contains:
+ * - `flow_name`: derived from the YAML `config.name` field if present, otherwise
+ *   the flow filename without extension.
+ *   See: https://github.com/mobile-dev-inc/Maestro/blob/c0e95fd/maestro-cli/src/main/java/maestro/cli/runner/TestRunner.kt#L70
+ * - `flow_file_path`: absolute path to the original flow YAML file.
+ * - `outputs`: screenshot defect data (unused here).
+ *
+ * Filename format: `ai-(flowName).json` where `/` in flowName is replaced with `_`.
+ * See: https://github.com/mobile-dev-inc/Maestro/blob/c0e95fd/maestro-cli/src/main/java/maestro/cli/report/TestDebugReporter.kt#L67
+ */
+async function parseFlowMetadata(filePath) {
+    try {
+        const content = await promises_1.default.readFile(filePath, 'utf-8');
+        const data = JSON.parse(content);
+        return FlowMetadataFileSchema.parse(data);
+    }
+    catch {
+        return null;
+    }
+}
+async function parseMaestroResults(junitDirectory, testsDirectory, projectRoot) {
+    // 1. Parse JUnit XML files (primary source)
+    const junitResults = await parseJUnitTestCases(junitDirectory);
+    if (junitResults.length === 0) {
+        return [];
+    }
+    // 2. Parse ai-*.json from debug output for flow_file_path + retryCount
+    const flowPathMap = new Map(); // flowName → flowFilePath
+    const flowOccurrences = new Map(); // flowName → count
+    let entries;
+    try {
+        entries = await promises_1.default.readdir(testsDirectory);
+    }
+    catch {
+        entries = [];
+    }
+    const timestampDirs = entries.filter(name => TIMESTAMP_DIR_PATTERN.test(name)).sort();
+    for (const dir of timestampDirs) {
+        const dirPath = path_1.default.join(testsDirectory, dir);
+        let files;
+        try {
+            files = await promises_1.default.readdir(dirPath);
+        }
+        catch {
+            continue;
+        }
+        for (const file of files) {
+            const flowKey = extractFlowKey(file, 'ai');
+            if (!flowKey) {
+                continue;
+            }
+            const metadata = await parseFlowMetadata(path_1.default.join(dirPath, file));
+            if (!metadata) {
+                continue;
+            }
+            // Track latest path (last timestamp dir wins)
+            flowPathMap.set(metadata.flow_name, metadata.flow_file_path);
+            // Count occurrences for retryCount
+            flowOccurrences.set(metadata.flow_name, (flowOccurrences.get(metadata.flow_name) ?? 0) + 1);
+        }
+    }
+    // 3. Merge: JUnit results + ai-*.json metadata
+    const results = [];
+    for (const junit of junitResults) {
+        const flowFilePath = flowPathMap.get(junit.name);
+        const relativePath = flowFilePath
+            ? await relativizePathAsync(flowFilePath, projectRoot)
+            : junit.name; // fallback: use flow name if ai-*.json not found
+        const occurrences = flowOccurrences.get(junit.name) ?? 0;
+        const retryCount = Math.max(0, occurrences - 1);
+        results.push({
+            name: junit.name,
+            path: relativePath,
+            status: junit.status,
+            errorMessage: junit.errorMessage,
+            duration: junit.duration,
+            retryCount,
+            tags: junit.tags,
+            properties: junit.properties,
+        });
+    }
+    return results;
+}
+async function relativizePathAsync(flowFilePath, projectRoot) {
+    if (!path_1.default.isAbsolute(flowFilePath)) {
+        return flowFilePath;
+    }
+    // Resolve symlinks (e.g., /tmp -> /private/tmp on macOS) for consistent comparison
+    let resolvedRoot = projectRoot;
+    let resolvedFlow = flowFilePath;
+    try {
+        resolvedRoot = await promises_1.default.realpath(projectRoot);
+    }
+    catch { }
+    try {
+        resolvedFlow = await promises_1.default.realpath(flowFilePath);
+    }
+    catch { }
+    const relative = path_1.default.relative(resolvedRoot, resolvedFlow);
+    if (relative.startsWith('..')) {
+        return flowFilePath;
+    }
+    return relative;
+}

package/dist/steps/functions/reportMaestroTestResults.d.ts

@@ -0,0 +1,3 @@
+import { BuildFunction } from '@expo/steps';
+import { CustomBuildContext } from '../../customBuildContext';
+export declare function createReportMaestroTestResultsFunction(ctx: CustomBuildContext): BuildFunction;

package/dist/steps/functions/reportMaestroTestResults.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createReportMaestroTestResultsFunction = createReportMaestroTestResultsFunction;
+const steps_1 = require("@expo/steps");
+const gql_tada_1 = require("gql.tada");
+const maestroResultParser_1 = require("./maestroResultParser");
+const CREATE_MUTATION = (0, gql_tada_1.graphql)(`
+  mutation CreateWorkflowDeviceTestCaseResults($input: CreateWorkflowDeviceTestCaseResultsInput!) {
+    workflowDeviceTestCaseResult {
+      createWorkflowDeviceTestCaseResults(input: $input) {
+        id
+      }
+    }
+  }
+`);
+const FLOW_STATUS_TO_TEST_CASE_RESULT_STATUS = {
+    passed: 'PASSED',
+    failed: 'FAILED',
+};
+function createReportMaestroTestResultsFunction(ctx) {
+    return new steps_1.BuildFunction({
+        namespace: 'eas',
+        id: 'report_maestro_test_results',
+        name: 'Report Maestro Test Results',
+        __metricsId: 'eas/report_maestro_test_results',
+        inputProviders: [
+            steps_1.BuildStepInput.createProvider({
+                id: 'junit_report_directory',
+                required: false,
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.STRING,
+                defaultValue: '${{ env.HOME }}/.maestro/tests',
+            }),
+            steps_1.BuildStepInput.createProvider({
+                id: 'tests_directory',
+                required: false,
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.STRING,
+                defaultValue: '${{ env.HOME }}/.maestro/tests',
+            }),
+        ],
+        fn: async (stepsCtx, { inputs }) => {
+            const { logger } = stepsCtx;
+            const workflowJobId = stepsCtx.global.env.__WORKFLOW_JOB_ID;
+            if (!workflowJobId) {
+                logger.info('Not running in a workflow job, skipping test results report');
+                return;
+            }
+            const junitDirectory = inputs.junit_report_directory.value ?? '';
+            if (!junitDirectory) {
+                logger.info('No JUnit directory provided, skipping test results report');
+                return;
+            }
+            const testsDirectory = inputs.tests_directory.value;
+            try {
+                const flowResults = await (0, maestroResultParser_1.parseMaestroResults)(junitDirectory, testsDirectory, stepsCtx.workingDirectory);
+                if (flowResults.length === 0) {
+                    logger.info('No maestro test results found, skipping report');
+                    return;
+                }
+                // Maestro allows overriding flow names via config, so different flow files can share
+                // the same name. JUnit XML only contains names (not file paths), making it impossible
+                // to map duplicates back to their original flow files. Skip and let the user fix it.
+                const names = flowResults.map(r => r.name);
+                const duplicates = names.filter((n, i) => names.indexOf(n) !== i);
+                if (duplicates.length > 0) {
+                    logger.error(`Duplicate test case names found in JUnit output: ${[...new Set(duplicates)].join(', ')}. Skipping report. Ensure each Maestro flow has a unique name.`);
+                    return;
+                }
+                const testCaseResults = flowResults.flatMap(f => {
+                    const status = FLOW_STATUS_TO_TEST_CASE_RESULT_STATUS[f.status];
+                    if (!status) {
+                        return [];
+                    }
+                    return [
+                        {
+                            name: f.name,
+                            path: f.path,
+                            status,
+                            errorMessage: f.errorMessage,
+                            duration: f.duration,
+                            retryCount: f.retryCount,
+                            tags: f.tags,
+                            properties: f.properties,
+                        },
+                    ];
+                });
+                const result = await ctx.graphqlClient
+                    .mutation(CREATE_MUTATION, {
+                    input: {
+                        workflowJobId,
+                        testCaseResults,
+                    },
+                })
+                    .toPromise();
+                if (result.error) {
+                    logger.error({ error: result.error }, 'GraphQL error creating test case results');
+                    return;
+                }
+                logger.info(`Reported ${testCaseResults.length} test case result(s).`);
+            }
+            catch (error) {
+                logger.error({ err: error }, 'Failed to create test case results');
+            }
+        },
+    });
+}

package/dist/steps/functions/uploadToAsc.d.ts

@@ -1,2 +1,5 @@
 import { BuildFunction } from '@expo/steps';
 export declare function createUploadToAscBuildFunction(): BuildFunction;
+export declare function isClosedVersionTrainError(messages: {
+    code: string;
+}[]): boolean;

package/dist/steps/functions/uploadToAsc.js

@@ -37,6 +37,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createUploadToAscBuildFunction = createUploadToAscBuildFunction;
+exports.isClosedVersionTrainError = isClosedVersionTrainError;
+const errors_1 = require("@expo/eas-build-job/dist/errors");
 const steps_1 = require("@expo/steps");
 const fs_extra_1 = __importDefault(require("fs-extra"));
 const jose = __importStar(require("jose"));
@@ -45,6 +47,7 @@ const node_path_1 = __importDefault(require("node:path"));
 const promises_1 = require("node:timers/promises");
 const zod_1 = require("zod");
 const AscApiClient_1 = require("../utils/ios/AscApiClient");
+const AscApiUtils_1 = require("../utils/ios/AscApiUtils");
 function createUploadToAscBuildFunction() {
     return new steps_1.BuildFunction({
         namespace: 'eas',
@@ -128,26 +131,14 @@ function createUploadToAscBuildFunction() {
                 .sign(privateKey);
             const client = new AscApiClient_1.AscApiClient({ token, logger: stepsCtx.logger });
             stepsCtx.logger.info('Reading App information...');
-            const appResponse = await client.getAsync('/v1/apps/:id', { 'fields[apps]': ['bundleId', 'name'] }, { id: appleAppIdentifier });
+            const appResponse = await AscApiUtils_1.AscApiUtils.getAppInfoAsync({ client, appleAppIdentifier });
             stepsCtx.logger.info(`Uploading Build to "${appResponse.data.attributes.name}" (${appResponse.data.attributes.bundleId})...`);
             stepsCtx.logger.info('Creating Build Upload...');
-            const buildUploadResponse = await client.postAsync('/v1/buildUploads', {
-                data: {
-                    type: 'buildUploads',
-                    attributes: {
-                        platform: 'IOS',
-                        cfBundleShortVersionString: bundleShortVersion,
-                        cfBundleVersion: bundleVersion,
-                    },
-                    relationships: {
-                        app: {
-                            data: {
-                                type: 'apps',
-                                id: appleAppIdentifier,
-                            },
-                        },
-                    },
-                },
+            const buildUploadResponse = await AscApiUtils_1.AscApiUtils.createBuildUploadAsync({
+                client,
+                appleAppIdentifier,
+                bundleShortVersion,
+                bundleVersion,
             });
             const buildUploadId = buildUploadResponse.data.id;
             const buildUploadUrl = `https://appstoreconnect.apple.com/apps/${appleAppIdentifier}/testflight/ios/${buildUploadId}`;
@@ -223,10 +214,18 @@ function createUploadToAscBuildFunction() {
             }
             stepsCtx.logger.info('Checking build upload status...');
             const waitingForBuildStartedAt = Date.now();
+            const waitingLogIntervalMs = 10 * 1000;
+            let lastWaitLogTime = 0;
+            let lastWaitLogState = null;
             while (Date.now() - waitingForBuildStartedAt < 30 * 60 * 1000 /* 30 minutes */) {
                 const { data: { attributes: { state }, }, } = await client.getAsync(`/v1/buildUploads/:id`, { 'fields[buildUploads]': ['state', 'build'], include: ['build'] }, { id: buildUploadId });
                 if (state.state === 'AWAITING_UPLOAD' || state.state === 'PROCESSING') {
-                    stepsCtx.logger.info(`Waiting for build upload to complete... (status = ${state.state})`);
+                    const now = Date.now();
+                    if (lastWaitLogState !== state.state || now - lastWaitLogTime >= waitingLogIntervalMs) {
+                        stepsCtx.logger.info(`Waiting for build upload to complete... (status = ${state.state})`);
+                        lastWaitLogTime = now;
+                        lastWaitLogState = state.state;
+                    }
                     await (0, promises_1.setTimeout)(2000);
                     continue;
                 }
@@ -242,6 +241,10 @@ function createUploadToAscBuildFunction() {
                     stepsCtx.logger.error(`Errors:\n${itemizeMessages(errors)}\n`);
                 }
                 if (state.state === 'FAILED') {
+                    if (isClosedVersionTrainError(errors)) {
+                        throw new errors_1.UserFacingError('EAS_UPLOAD_TO_ASC_CLOSED_VERSION_TRAIN', `Build upload was rejected by App Store Connect because the ${bundleShortVersion} version train is closed. ` +
+                            'Bump the iOS app version (CFBundleShortVersionString, e.g. expo.version) to a higher version and submit again.');
+                    }
                     throw new Error(`Build upload (ID: ${buildUploadId}) failed.`);
                 }
                 else if (state.state === 'COMPLETE') {
@@ -255,6 +258,9 @@ function createUploadToAscBuildFunction() {
 function itemizeMessages(messages) {
     return `- ${messages.map(m => `${m.description} (${m.code})`).join('\n- ')}`;
 }
+function isClosedVersionTrainError(messages) {
+    return (messages.length > 0 && messages.every(message => ['90062', '90186'].includes(message.code)));
+}
 async function uploadChunksAsync({ uploadOperations, ipaPath, logger, }) {
     const fd = await fs_extra_1.default.open(ipaPath, 'r');
     try {

package/dist/steps/utils/ios/AscApiClient.d.ts

@@ -1,6 +1,36 @@
 import { bunyan } from '@expo/logger';
 import { z } from 'zod';
+declare const AscErrorResponseSchema: z.ZodObject<{
+    errors: z.ZodArray<z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        status: z.ZodOptional<z.ZodString>;
+        code: z.ZodOptional<z.ZodString>;
+        title: z.ZodOptional<z.ZodString>;
+        detail: z.ZodOptional<z.ZodString>;
+        source: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
 declare const GetApi: {
+    '/v1/apps': {
+        path: z.ZodObject<{}, z.core.$strip>;
+        request: z.ZodObject<{
+            'fields[apps]': z.ZodArray<z.ZodEnum<{
+                name: "name";
+                bundleId: "bundleId";
+            }>>;
+            limit: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>;
+        response: z.ZodObject<{
+            data: z.ZodArray<z.ZodObject<{
+                type: z.ZodLiteral<"apps">;
+                id: z.ZodString;
+                attributes: z.ZodObject<{
+                    bundleId: z.ZodString;
+                    name: z.ZodString;
+                }, z.core.$strip>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+    };
     '/v1/apps/:id': {
         path: z.ZodObject<{
             id: z.ZodString;
@@ -38,10 +68,10 @@ declare const GetApi: {
                 attributes: z.ZodObject<{
                     assetDeliveryState: z.ZodObject<{
                         state: z.ZodEnum<{
+                            FAILED: "FAILED";
                             AWAITING_UPLOAD: "AWAITING_UPLOAD";
                             UPLOAD_COMPLETE: "UPLOAD_COMPLETE";
                             COMPLETE: "COMPLETE";
-                            FAILED: "FAILED";
                         }>;
                         errors: z.ZodOptional<z.ZodArray<z.ZodObject<{
                             code: z.ZodString;
@@ -76,9 +106,9 @@ declare const GetApi: {
                 attributes: z.ZodObject<{
                     state: z.ZodObject<{
                         state: z.ZodEnum<{
+                            FAILED: "FAILED";
                             AWAITING_UPLOAD: "AWAITING_UPLOAD";
                             COMPLETE: "COMPLETE";
-                            FAILED: "FAILED";
                             PROCESSING: "PROCESSING";
                         }>;
                         infos: z.ZodOptional<z.ZodArray<z.ZodObject<{
@@ -203,10 +233,10 @@ declare const PatchApi: {
                 attributes: z.ZodObject<{
                     assetDeliveryState: z.ZodObject<{
                         state: z.ZodEnum<{
+                            FAILED: "FAILED";
                             AWAITING_UPLOAD: "AWAITING_UPLOAD";
                             UPLOAD_COMPLETE: "UPLOAD_COMPLETE";
                             COMPLETE: "COMPLETE";
-                            FAILED: "FAILED";
                         }>;
                         errors: z.ZodOptional<z.ZodArray<z.ZodObject<{
                             code: z.ZodString;
@@ -222,6 +252,12 @@ declare const PatchApi: {
         }, z.core.$strip>;
     };
 };
+export type AscApiClientGetApi = {
+    [Path in keyof typeof GetApi]: {
+        request: z.input<(typeof GetApi)[Path]['request']>;
+        response: z.output<(typeof GetApi)[Path]['response']>;
+    };
+};
 export type AscApiClientPostApi = {
     [Path in keyof typeof PostApi]: {
         request: z.input<(typeof PostApi)[Path]['request']>;
@@ -234,6 +270,13 @@ export type AscApiClientPatchApi = {
         response: z.output<(typeof PatchApi)[Path]['response']>;
     };
 };
+export declare class AscApiRequestError extends Error {
+    readonly status: number;
+    readonly responseJson: z.output<typeof AscErrorResponseSchema>;
+    constructor(message: string, status: number, responseJson: z.output<typeof AscErrorResponseSchema>, options?: {
+        cause?: unknown;
+    });
+}
 export declare class AscApiClient {
     private readonly baseUrl;
     private readonly token;

package/dist/steps/utils/ios/AscApiClient.js

@@ -3,11 +3,42 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AscApiClient = void 0;
+exports.AscApiClient = exports.AscApiRequestError = void 0;
 const results_1 = require("@expo/results");
 const node_fetch_1 = __importDefault(require("node-fetch"));
 const zod_1 = require("zod");
+const AscErrorResponseSchema = zod_1.z.object({
+    errors: zod_1.z
+        .array(zod_1.z.object({
+        id: zod_1.z.string().optional(),
+        status: zod_1.z.string().optional(),
+        code: zod_1.z.string().optional(),
+        title: zod_1.z.string().optional(),
+        detail: zod_1.z.string().optional(),
+        source: zod_1.z.unknown().optional(),
+    }))
+        .min(1),
+});
 const GetApi = {
+    '/v1/apps': {
+        path: zod_1.z.object({}),
+        request: zod_1.z.object({
+            'fields[apps]': zod_1.z.array(zod_1.z.enum(['bundleId', 'name'])).refine(opts => {
+                return opts.includes('bundleId') && opts.includes('name');
+            }),
+            limit: zod_1.z.number().int().min(1).max(200).optional(),
+        }),
+        response: zod_1.z.object({
+            data: zod_1.z.array(zod_1.z.object({
+                type: zod_1.z.literal('apps'),
+                id: zod_1.z.string(),
+                attributes: zod_1.z.object({
+                    bundleId: zod_1.z.string(),
+                    name: zod_1.z.string(),
+                }),
+            })),
+        }),
+    },
     '/v1/apps/:id': {
         path: zod_1.z.object({
             id: zod_1.z.string(),
@@ -212,6 +243,16 @@ const PatchApi = {
         }),
     },
 };
+class AscApiRequestError extends Error {
+    status;
+    responseJson;
+    constructor(message, status, responseJson, options) {
+        super(message, { cause: options?.cause });
+        this.status = status;
+        this.responseJson = responseJson;
+    }
+}
+exports.AscApiRequestError = AscApiRequestError;
 class AscApiClient {
     baseUrl = 'https://api.appstoreconnect.apple.com';
     token;
@@ -283,11 +324,20 @@ class AscApiClient {
         });
         if (!response.ok) {
             const text = await response.text();
+            const parsedAscErrorResponse = await (0, results_1.asyncResult)((async () => AscErrorResponseSchema.parse(JSON.parse(text)))());
+            if (parsedAscErrorResponse.ok) {
+                throw new AscApiRequestError(`Unexpected response (${response.status}) from App Store Connect: ${text}`, response.status, parsedAscErrorResponse.value, { cause: response });
+            }
             throw new Error(`Unexpected response (${response.status}) from App Store Connect: ${text}`, {
                 cause: response,
             });
         }
-        const json = await response.json();
+        const text = await response.text();
+        const parsedJson = await (0, results_1.asyncResult)((async () => JSON.parse(text))());
+        if (!parsedJson.ok) {
+            throw new Error(`Malformed JSON response from App Store Connect (${response.status}): ${text}`);
+        }
+        const json = parsedJson.value;
         this.logger?.debug(`Response from App Store Connect: ${JSON.stringify(json, null, 2)}`);
         const parsedResponse = await (0, results_1.asyncResult)((async () => responseSchema.parse(json))());
         if (!parsedResponse.ok) {

package/dist/steps/utils/ios/AscApiUtils.d.ts

@@ -0,0 +1,13 @@
+import { AscApiClient, AscApiClientGetApi, AscApiClientPostApi } from './AscApiClient';
+export declare namespace AscApiUtils {
+    function getAppInfoAsync({ client, appleAppIdentifier, }: {
+        client: Pick<AscApiClient, 'getAsync'>;
+        appleAppIdentifier: string;
+    }): Promise<AscApiClientGetApi['/v1/apps/:id']['response']>;
+    function createBuildUploadAsync({ client, appleAppIdentifier, bundleShortVersion, bundleVersion, }: {
+        client: Pick<AscApiClient, 'postAsync'>;
+        appleAppIdentifier: string;
+        bundleShortVersion: string;
+        bundleVersion: string;
+    }): Promise<AscApiClientPostApi['/v1/buildUploads']['response']>;
+}

package/dist/steps/utils/ios/AscApiUtils.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AscApiUtils = void 0;
+const errors_1 = require("@expo/eas-build-job/dist/errors");
+const AscApiClient_1 = require("./AscApiClient");
+var AscApiUtils;
+(function (AscApiUtils) {
+    async function getAppInfoAsync({ client, appleAppIdentifier, }) {
+        try {
+            return await client.getAsync('/v1/apps/:id', { 'fields[apps]': ['bundleId', 'name'] }, { id: appleAppIdentifier });
+        }
+        catch (error) {
+            const notFoundErrors = error instanceof AscApiClient_1.AscApiRequestError && error.status === 404
+                ? error.responseJson.errors
+                : [];
+            const isAppNotFoundError = notFoundErrors.length > 0 && notFoundErrors.every(item => item.code === 'NOT_FOUND');
+            if (!isAppNotFoundError) {
+                throw error;
+            }
+            let visibleAppsSummary = null;
+            try {
+                visibleAppsSummary = await getVisibleAppsSummaryAsync(client);
+            }
+            catch {
+                // Don't hide the original NOT_FOUND error with a secondary lookup failure.
+                throw error;
+            }
+            throw new errors_1.UserFacingError('EAS_UPLOAD_TO_ASC_APP_NOT_FOUND', `App Store Connect app for application identifier ${appleAppIdentifier} was not found. ` +
+                'Verify the configured application identifier and that the App Store Connect API key has access to the application in the correct App Store Connect account.' +
+                (visibleAppsSummary
+                    ? `\n\nExample applications visible to this API key:\n${visibleAppsSummary}`
+                    : ''), {
+                cause: error,
+                docsUrl: 'https://expo.fyi/asc-app-id',
+            });
+        }
+    }
+    AscApiUtils.getAppInfoAsync = getAppInfoAsync;
+    async function createBuildUploadAsync({ client, appleAppIdentifier, bundleShortVersion, bundleVersion, }) {
+        try {
+            return await client.postAsync('/v1/buildUploads', {
+                data: {
+                    type: 'buildUploads',
+                    attributes: {
+                        platform: 'IOS',
+                        cfBundleShortVersionString: bundleShortVersion,
+                        cfBundleVersion: bundleVersion,
+                    },
+                    relationships: {
+                        app: {
+                            data: {
+                                type: 'apps',
+                                id: appleAppIdentifier,
+                            },
+                        },
+                    },
+                },
+            });
+        }
+        catch (error) {
+            const errors = error instanceof AscApiClient_1.AscApiRequestError && error.status === 409
+                ? error.responseJson.errors
+                : [];
+            const isDuplicateVersionError = errors.length > 0 &&
+                errors.every(item => item.code === 'ENTITY_ERROR.ATTRIBUTE.INVALID.DUPLICATE');
+            if (isDuplicateVersionError) {
+                throw new errors_1.UserFacingError('EAS_UPLOAD_TO_ASC_VERSION_DUPLICATE', `Increment Build Number: Build number ${bundleVersion} for app version ${bundleShortVersion} has already been used. ` +
+                    'App Store Connect requires unique build numbers within each app version (version train). ' +
+                    'Increment it by setting ios.buildNumber in app.json, or set "autoIncrement": true in eas.json (recommended). Then rebuild and resubmit.', {
+                    cause: error,
+                    docsUrl: 'https://docs.expo.dev/build-reference/app-versions/',
+                });
+            }
+            throw error;
+        }
+    }
+    AscApiUtils.createBuildUploadAsync = createBuildUploadAsync;
+})(AscApiUtils || (exports.AscApiUtils = AscApiUtils = {}));
+async function getVisibleAppsSummaryAsync(client) {
+    const appsResponse = await client.getAsync('/v1/apps', {
+        'fields[apps]': ['bundleId', 'name'],
+        limit: 10,
+    });
+    if (appsResponse.data.length === 0) {
+        return '  (none)';
+    }
+    return appsResponse.data
+        .map(app => `- ${app.attributes.name} (${app.attributes.bundleId}) (ID: ${app.id})`)
+        .join('\n');
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@expo/build-tools",
-  "version": "18.0.2",
+  "version": "18.1.0",
   "bugs": "https://github.com/expo/eas-cli/issues",
   "license": "BUSL-1.1",
   "author": "Expo <support@expo.io>",
@@ -53,6 +53,7 @@
     "@urql/core": "^6.0.1",
     "bplist-parser": "0.3.2",
     "fast-glob": "^3.3.2",
+    "fast-xml-parser": "^4.4.1",
     "fs-extra": "^11.2.0",
     "gql.tada": "^1.8.13",
     "joi": "^17.13.1",
@@ -96,5 +97,5 @@
     "typescript": "^5.5.4",
     "uuid": "^9.0.1"
   },
-  "gitHead": "d5da4f416791938a7c1ffdaf83a7c644e7aa6261"
+  "gitHead": "61b601de883b5c65d87163d8477b8a9250bc2de9"
 }