@expo/build-tools 21.4.0 → 21.5.1

package/dist/android/gradleProfile.js

@@ -75,6 +75,15 @@ function formatSeconds(ms) {
     }
     return `${s.toFixed(1)}s`;
 }
+function truncateMiddle(value, width) {
+    if (value.length <= width) {
+        return value;
+    }
+    const availableWidth = width - 1;
+    const startWidth = Math.ceil(availableWidth / 2);
+    const endWidth = Math.floor(availableWidth / 2);
+    return `${value.slice(0, startWidth)}…${value.slice(-endWidth)}`;
+}
 function formatGradleProfileReport(tasks) {
     // Filter out tasks under 1 second
     const significantTasks = tasks.filter(t => t.durationMs >= 1000);
@@ -119,7 +128,10 @@ function formatGradleProfileReport(tasks) {
     // Compute totals from individual tasks only (avoid double-counting)
     const totalMs = individualTasks.reduce((sum, t) => sum + t.durationMs, 0);
     const maxMs = totalMs || 1;
-    const nameWidth = Math.max(4, ...rows.map(r => r.displayName.length)) + 2;
+    // Keep the report close to the xclogparser table width. Gradle task names can be very long,
+    // so allowing them to grow the first column without a limit makes the table difficult to read.
+    const maxNameWidth = 48;
+    const nameWidth = Math.min(maxNameWidth, Math.max(4, ...rows.map(row => row.displayName.length)) + 2);
     const barMaxWidth = 20;
     const header = '┌─' +
         '─'.repeat(nameWidth) +
@@ -163,7 +175,7 @@ function formatGradleProfileReport(tasks) {
         const bar = '█'.repeat(barLength) + '░'.repeat(barMaxWidth - barLength);
         const result = row.task.result === '(total)' ? 'total' : row.task.result;
         lines.push('│ ' +
-            row.displayName.padEnd(nameWidth) +
+            truncateMiddle(row.displayName, nameWidth).padEnd(nameWidth) +
             ' │ ' +
             formatSeconds(row.task.durationMs).padStart(10) +
             ' │ ' +

package/dist/builders/custom.js

@@ -15,6 +15,7 @@ const projectSources_1 = require("../common/projectSources");
 const customBuildContext_1 = require("../customBuildContext");
 const datadog_1 = require("../datadog");
 const xcodeBuildLogs_1 = require("../ios/xcodeBuildLogs");
+const compositeFunctions_1 = require("../steps/compositeFunctions");
 const easFunctionGroups_1 = require("../steps/easFunctionGroups");
 const easFunctions_1 = require("../steps/easFunctions");
 const retry_1 = require("../utils/retry");
@@ -44,20 +45,27 @@ async function runCustomBuildAsync(ctx) {
     const globalContext = new steps_1.BuildStepGlobalContext(customBuildCtx, false);
     const easFunctions = (0, easFunctions_1.getEasFunctions)(customBuildCtx);
     const easFunctionGroups = (0, easFunctionGroups_1.getEasFunctionGroups)(customBuildCtx);
-    const parser = ctx.job.steps
-        ? new steps_1.StepsConfigParser(globalContext, {
-            externalFunctions: easFunctions,
-            externalFunctionGroups: easFunctionGroups,
-            steps: ctx.job.steps,
-            hooks: ctx.job.hooks,
-        })
-        : new steps_1.BuildConfigParser(globalContext, {
-            externalFunctions: easFunctions,
-            externalFunctionGroups: easFunctionGroups,
-            configPath: path_1.default.join(ctx.getReactNativeProjectDirectory(customBuildCtx.projectSourceDirectory), (0, nullthrows_1.default)(ctx.job.customBuildConfig?.path, 'Steps or custom build config path are required in custom jobs')),
-        });
     const workflow = await ctx.runBuildPhase(eas_build_job_1.BuildPhase.PARSE_CUSTOM_WORKFLOW_CONFIG, async () => {
         try {
+            const projectRoot = ctx.getReactNativeProjectDirectory(customBuildCtx.projectSourceDirectory);
+            const parser = ctx.job.steps
+                ? new steps_1.StepsConfigParser(globalContext, {
+                    externalFunctions: easFunctions,
+                    externalFunctionGroups: easFunctionGroups,
+                    steps: ctx.job.steps,
+                    hooks: ctx.job.hooks,
+                    // Eager for job steps (always run), lazy loader for hooks (running anchors only).
+                    compositeFunctionCatalog: await (0, compositeFunctions_1.buildCompositeFunctionCatalogAsync)(projectRoot, {
+                        steps: ctx.job.steps,
+                        logger: ctx.logger,
+                    }),
+                    loadCompositeFunction: (0, compositeFunctions_1.createCompositeFunctionLoader)(projectRoot, ctx.logger),
+                })
+                : new steps_1.BuildConfigParser(globalContext, {
+                    externalFunctions: easFunctions,
+                    externalFunctionGroups: easFunctionGroups,
+                    configPath: path_1.default.join(projectRoot, (0, nullthrows_1.default)(ctx.job.customBuildConfig?.path, 'Steps or custom build config path are required in custom jobs')),
+                });
             return await parser.parseAsync();
         }
         catch (parseError) {

package/dist/common/git.d.ts

@@ -7,3 +7,7 @@ export declare function shallowCloneRepositoryAsync({ logger, archiveSource, des
     };
     destinationDirectory: string;
 }): Promise<void>;
+export declare function fetchAndCheckoutRefAsync({ ref, repositoryDirectory, }: {
+    ref: string;
+    repositoryDirectory: string;
+}): Promise<void>;

package/dist/common/git.js

@@ -4,7 +4,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.shallowCloneRepositoryAsync = shallowCloneRepositoryAsync;
+exports.fetchAndCheckoutRefAsync = fetchAndCheckoutRefAsync;
+const eas_build_job_1 = require("@expo/eas-build-job");
 const turtle_spawn_1 = __importDefault(require("@expo/turtle-spawn"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
 async function shallowCloneRepositoryAsync({ logger, archiveSource, destinationDirectory, }) {
     const { repositoryUrl } = archiveSource;
     try {
@@ -47,6 +51,35 @@ async function shallowCloneRepositoryAsync({ logger, archiveSource, destinationD
         throw err;
     }
 }
+async function fetchAndCheckoutRefAsync({ ref, repositoryDirectory, }) {
+    if (!(await fs_extra_1.default.pathExists(path_1.default.join(repositoryDirectory, '.git')))) {
+        throw new eas_build_job_1.UserError('EAS_CHECKOUT_NOT_A_GIT_REPOSITORY', `Cannot check out ref "${ref}": ${repositoryDirectory} is not a Git repository.`);
+    }
+    const { name, type } = getStrippedBranchOrTagName(ref);
+    const isCommitHash = type === 'other' && /^([0-9a-f]{40}|[0-9a-f]{64})$/.test(name);
+    const refToFetch = type === 'branch' ? `refs/heads/${name}` : type === 'tag' ? `refs/tags/${name}` : name;
+    try {
+        await (0, turtle_spawn_1.default)('git', ['fetch', 'origin', '--depth', '1', '--no-tags', refToFetch], {
+            cwd: repositoryDirectory,
+        });
+        if (type === 'tag') {
+            await (0, turtle_spawn_1.default)('git', ['checkout', 'FETCH_HEAD'], { cwd: repositoryDirectory });
+            // --force because the initial clone may have already created this tag.
+            await (0, turtle_spawn_1.default)('git', ['tag', '--force', name], { cwd: repositoryDirectory });
+        }
+        else if (isCommitHash) {
+            await (0, turtle_spawn_1.default)('git', ['checkout', 'FETCH_HEAD'], { cwd: repositoryDirectory });
+        }
+        else {
+            // -B because a branch with this name may exist from the initial clone.
+            await (0, turtle_spawn_1.default)('git', ['checkout', '-B', name, 'FETCH_HEAD'], { cwd: repositoryDirectory });
+        }
+    }
+    catch (err) {
+        // Git output is not relayed because it may contain the credentialed repository URL.
+        throw new eas_build_job_1.UserError('EAS_CHECKOUT_FAILED_TO_CHECKOUT_REF', `Failed to fetch and check out ref "${ref}". Make sure it is a branch, tag, or commit SHA reachable in the source repository.`, { cause: err });
+    }
+}
 function getSanitizedGitUrl(maybeGitUrl) {
     try {
         const url = new URL(maybeGitUrl);
@@ -60,7 +93,7 @@ function getSanitizedGitUrl(maybeGitUrl) {
     }
 }
 function getStrippedBranchOrTagName(ref) {
-    const branchRegex = /(\/?refs)?\/?heads\/(.+)/;
+    const branchRegex = /^\/?(refs\/)?heads\/(.+)$/;
     const branchMatch = ref.match(branchRegex);
     if (branchMatch) {
         return {
@@ -68,7 +101,7 @@ function getStrippedBranchOrTagName(ref) {
             type: 'branch',
         };
     }
-    const tagRegex = /(\/?refs)?\/?tags\/(.+)/;
+    const tagRegex = /^\/?(refs\/)?tags\/(.+)$/;
     const tagMatch = ref.match(tagRegex);
     if (tagMatch) {
         return {

package/dist/common/jobHooks.js

@@ -4,6 +4,7 @@ exports.parseJobHooksAsync = parseJobHooksAsync;
 const eas_build_job_1 = require("@expo/eas-build-job");
 const steps_1 = require("@expo/steps");
 const customBuildContext_1 = require("../customBuildContext");
+const compositeFunctions_1 = require("../steps/compositeFunctions");
 const easFunctionGroups_1 = require("../steps/easFunctionGroups");
 const easFunctions_1 = require("../steps/easFunctions");
 /**
@@ -58,6 +59,8 @@ async function parseJobHooksAsync(ctx, wrappedAnchors) {
     // outputs accumulate across keys.
     const hookEntriesByKey = {};
     const orderedSteps = [];
+    const compositeFunctionCatalog = {};
+    const loadCompositeFunction = (0, compositeFunctions_1.createCompositeFunctionLoader)(ctx.getReactNativeProjectDirectory(), ctx.logger);
     for (const anchor of wrappedAnchors) {
         for (const side of ['before', 'after']) {
             const key = `${side}_${anchor}`;
@@ -67,9 +70,16 @@ async function parseJobHooksAsync(ctx, wrappedAnchors) {
             }
             let entries;
             try {
+                // Extended per key so a bad `uses:` path is attributed to that hook key.
+                await (0, steps_1.extendCompositeFunctionCatalogFromStepsAsync)({
+                    catalog: compositeFunctionCatalog,
+                    rootSteps: steps,
+                    loadCompositeFunction,
+                });
                 entries = await (0, steps_1.constructHookEntriesAsync)(globalContext, steps, {
                     externalFunctions,
                     externalFunctionGroups,
+                    compositeFunctionCatalog,
                 });
             }
             catch (err) {

package/dist/generic.js

@@ -11,6 +11,7 @@ const promises_1 = __importDefault(require("fs/promises"));
 const nullthrows_1 = __importDefault(require("nullthrows"));
 const projectSources_1 = require("./common/projectSources");
 const customBuildContext_1 = require("./customBuildContext");
+const compositeFunctions_1 = require("./steps/compositeFunctions");
 const easFunctionGroups_1 = require("./steps/easFunctionGroups");
 const easFunctions_1 = require("./steps/easFunctions");
 const outputs_1 = require("./utils/outputs");
@@ -33,14 +34,22 @@ async function runGenericJobAsync(ctx) {
         });
     });
     const globalContext = new steps_1.BuildStepGlobalContext(customBuildCtx, false);
-    const parser = new steps_1.StepsConfigParser(globalContext, {
-        externalFunctions: (0, easFunctions_1.getEasFunctions)(customBuildCtx),
-        externalFunctionGroups: (0, easFunctionGroups_1.getEasFunctionGroups)(customBuildCtx),
-        steps: ctx.job.steps,
-        hooks: ctx.job.hooks,
-    });
     const workflow = await ctx.runBuildPhase(eas_build_job_1.BuildPhase.PARSE_CUSTOM_WORKFLOW_CONFIG, async () => {
         try {
+            const projectRoot = ctx.getReactNativeProjectDirectory(customBuildCtx.projectSourceDirectory);
+            // Eager for job steps (always run), lazy loader for hooks (running anchors only).
+            const compositeFunctionCatalog = await (0, compositeFunctions_1.buildCompositeFunctionCatalogAsync)(projectRoot, {
+                steps: ctx.job.steps,
+                logger: ctx.logger,
+            });
+            const parser = new steps_1.StepsConfigParser(globalContext, {
+                externalFunctions: (0, easFunctions_1.getEasFunctions)(customBuildCtx),
+                externalFunctionGroups: (0, easFunctionGroups_1.getEasFunctionGroups)(customBuildCtx),
+                steps: ctx.job.steps,
+                hooks: ctx.job.hooks,
+                compositeFunctionCatalog,
+                loadCompositeFunction: (0, compositeFunctions_1.createCompositeFunctionLoader)(projectRoot, ctx.logger),
+            });
             return await parser.parseAsync();
         }
         catch (parseError) {

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 import * as Builders from './builders';
+import HttpLogStream from './logging/HttpLogStream';
 import RemoteLoggerStream from './logging/RemoteLoggerStream';
-export { Builders, RemoteLoggerStream };
+export { Builders, HttpLogStream, RemoteLoggerStream };
 export { uploadWithSignedUrl } from './storage/uploadWithSignedUrl';
 export type { SignedUrl, UploadWithSignedUrlParams } from './storage/uploadWithSignedUrl';
 export { ArtifactToUpload, Artifacts, BuildContext, BuildContextOptions, CacheManager, LogBuffer, SkipNativeBuildError, } from './context';

package/dist/index.js

@@ -39,9 +39,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Sentry = exports.Datadog = exports.formatGradleProfileReport = exports.parseGradleProfile = exports.runHookIfPresent = exports.Hook = exports.findAndUploadXcodeBuildLogsAsync = exports.PackageManager = exports.SkipNativeBuildError = exports.BuildContext = exports.uploadWithSignedUrl = exports.RemoteLoggerStream = exports.Builders = void 0;
+exports.Sentry = exports.Datadog = exports.formatGradleProfileReport = exports.parseGradleProfile = exports.runHookIfPresent = exports.Hook = exports.findAndUploadXcodeBuildLogsAsync = exports.PackageManager = exports.SkipNativeBuildError = exports.BuildContext = exports.uploadWithSignedUrl = exports.RemoteLoggerStream = exports.HttpLogStream = exports.Builders = void 0;
 const Builders = __importStar(require("./builders"));
 exports.Builders = Builders;
+const HttpLogStream_1 = __importDefault(require("./logging/HttpLogStream"));
+exports.HttpLogStream = HttpLogStream_1.default;
 const RemoteLoggerStream_1 = __importDefault(require("./logging/RemoteLoggerStream"));
 exports.RemoteLoggerStream = RemoteLoggerStream_1.default;
 var uploadWithSignedUrl_1 = require("./storage/uploadWithSignedUrl");

package/dist/logging/HttpLogStream.d.ts

@@ -0,0 +1,28 @@
+import { bunyan } from '@expo/logger';
+import { Writable } from 'stream';
+/**
+ * A bunyan-compatible writable stream for sending logs over HTTP.
+ */
+export default class HttpLogStream extends Writable {
+    writable: boolean;
+    private readonly buffer;
+    private readonly url;
+    private readonly headers;
+    private readonly logger;
+    private readonly maxBatchBytes;
+    private readonly bufferRetentionMs;
+    private inFlightRequest;
+    constructor({ url, headers, logger, maxBatchBytes, bufferRetentionMs, }: {
+        url: string;
+        headers: Record<string, string>;
+        logger: bunyan;
+        maxBatchBytes?: number;
+        bufferRetentionMs?: number | null;
+    });
+    _write(chunk: unknown, _encoding: BufferEncoding, callback: (error?: Error | null) => void): void;
+    cleanUp(): Promise<void>;
+    private flush;
+    private takeBatch;
+    private trimExpiredBufferedLogs;
+    private sendBatch;
+}

package/dist/logging/HttpLogStream.js

@@ -0,0 +1,137 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const results_1 = require("@expo/results");
+const node_fetch_1 = __importDefault(require("node-fetch"));
+const stream_1 = require("stream");
+const retry_1 = require("../utils/retry");
+const MAX_BATCH_BYTES = 200_000;
+/**
+ * A bunyan-compatible writable stream for sending logs over HTTP.
+ */
+class HttpLogStream extends stream_1.Writable {
+    writable = true;
+    buffer = [];
+    url;
+    headers;
+    logger;
+    maxBatchBytes;
+    bufferRetentionMs;
+    inFlightRequest = null;
+    constructor({ url, headers, logger, maxBatchBytes = MAX_BATCH_BYTES, bufferRetentionMs = null, }) {
+        super({ objectMode: true });
+        this.url = url;
+        this.headers = headers;
+        this.logger = logger;
+        this.maxBatchBytes = maxBatchBytes;
+        this.bufferRetentionMs = bufferRetentionMs;
+    }
+    _write(chunk, _encoding, callback) {
+        if (typeof chunk !== 'object' || chunk === null) {
+            callback(new Error('Invalid log entry: expected an object'));
+            return;
+        }
+        this.trimExpiredBufferedLogs();
+        this.buffer.push({
+            enqueuedAt: Date.now(),
+            serialized: JSON.stringify(chunk),
+        });
+        this.flush();
+        callback();
+    }
+    async cleanUp() {
+        this.writable = false;
+        await this.flush({ isCleanup: true });
+    }
+    flush({ isCleanup = false } = {}) {
+        if (this.inFlightRequest) {
+            if (isCleanup) {
+                return this.inFlightRequest.then(() => {
+                    if (this.buffer.length > 0) {
+                        return this.flush({ isCleanup: true });
+                    }
+                });
+            }
+            return;
+        }
+        if (this.buffer.length === 0) {
+            return;
+        }
+        this.trimExpiredBufferedLogs();
+        if (this.buffer.length === 0) {
+            return;
+        }
+        const batch = this.takeBatch();
+        this.inFlightRequest = this.sendBatch(batch)
+            .catch(err => {
+            if (!isCleanup) {
+                // Keep logs in memory if upload fails so a later flush can retry.
+                this.buffer.unshift(...batch);
+                this.logger.error({ err }, 'Failed to send logs batch over HTTP');
+            }
+        })
+            .finally(() => {
+            this.inFlightRequest = null;
+        });
+        if (isCleanup) {
+            return this.inFlightRequest.then(() => {
+                if (this.buffer.length > 0) {
+                    return this.flush({ isCleanup: true });
+                }
+            });
+        }
+        void this.inFlightRequest.then(() => {
+            if (this.writable && this.buffer.length > 0) {
+                this.flush();
+            }
+        });
+    }
+    takeBatch() {
+        const batch = [];
+        let batchBytes = 0;
+        while (this.buffer.length > 0) {
+            const nextEntry = this.buffer[0];
+            const nextEntryBytes = Buffer.byteLength(nextEntry.serialized) + (batch.length > 0 ? Buffer.byteLength('\n') : 0);
+            if (batch.length > 0 && batchBytes + nextEntryBytes > this.maxBatchBytes) {
+                break;
+            }
+            batch.push(this.buffer.shift());
+            batchBytes += nextEntryBytes;
+        }
+        return batch;
+    }
+    trimExpiredBufferedLogs() {
+        if (this.bufferRetentionMs === null) {
+            return;
+        }
+        const cutoff = Date.now() - this.bufferRetentionMs;
+        while (this.buffer.length > 0 && this.buffer[0].enqueuedAt < cutoff) {
+            this.buffer.shift();
+        }
+    }
+    async sendBatch(logs) {
+        await (0, retry_1.retryAsync)(async () => {
+            const response = await (0, node_fetch_1.default)(this.url, {
+                method: 'POST',
+                headers: {
+                    ...this.headers,
+                    'Content-Type': 'application/x-ndjson',
+                },
+                body: logs.map(log => log.serialized).join('\n'),
+            });
+            if (!response.ok) {
+                const responseText = await (0, results_1.asyncResult)(response.text());
+                throw new Error(`Failed to upload logs: status=${response.status} statusText=${response.statusText} body=${responseText.value ?? '<error reading response body>'}`);
+            }
+        }, {
+            retryOptions: {
+                retries: 2,
+                retryIntervalMs: 1000,
+            },
+            logger: this.logger,
+        });
+    }
+}
+exports.default = HttpLogStream;

package/dist/steps/compositeFunctions.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Loads local function.yml files from the project and builds the catalog consumed by
+ * {@link StepsConfigParser}. Keeps filesystem I/O in build-tools; expansion logic lives in @expo/steps.
+ */
+import { bunyan } from '@expo/logger';
+import { CompositeFunctionCatalog, CompositeFunctionConfig, Step } from '@expo/eas-build-job';
+export declare function createCompositeFunctionLoader(projectRoot: string, logger?: bunyan): (compositeFunctionPath: string) => Promise<CompositeFunctionConfig>;
+export declare function buildCompositeFunctionCatalogAsync(projectRoot: string, { steps, logger }: {
+    steps: readonly Step[];
+    logger?: bunyan;
+}): Promise<CompositeFunctionCatalog>;

package/dist/steps/compositeFunctions.js

@@ -0,0 +1,62 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCompositeFunctionLoader = createCompositeFunctionLoader;
+exports.buildCompositeFunctionCatalogAsync = buildCompositeFunctionCatalogAsync;
+const eas_build_job_1 = require("@expo/eas-build-job");
+const steps_1 = require("@expo/steps");
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const yaml_1 = __importDefault(require("yaml"));
+const zod_1 = require("zod");
+async function loadLocalCompositeFunctionConfigAsync(projectRoot, compositeFunctionPath, { logger } = {}) {
+    const resolvedPath = (0, steps_1.resolveLocalCompositeFunctionPath)(projectRoot, compositeFunctionPath);
+    for (const ext of ['yml', 'yaml']) {
+        const absolutePath = path_1.default.join(resolvedPath, `function.${ext}`);
+        let rawContents;
+        try {
+            rawContents = await promises_1.default.readFile(absolutePath, 'utf-8');
+        }
+        catch (err) {
+            if (err?.code === 'ENOENT') {
+                continue;
+            }
+            throw new Error(`Failed to read local composite function "${compositeFunctionPath}" from ${absolutePath}`, {
+                cause: err,
+            });
+        }
+        let parsed;
+        try {
+            parsed = yaml_1.default.parse(rawContents);
+        }
+        catch (err) {
+            throw new Error(`Failed to parse local composite function "${compositeFunctionPath}" YAML at ${absolutePath}`, {
+                cause: err,
+            });
+        }
+        let config;
+        try {
+            config = eas_build_job_1.CompositeFunctionConfigZ.parse(parsed);
+        }
+        catch (err) {
+            if (err instanceof zod_1.ZodError) {
+                throw new Error(`Invalid composite function "${compositeFunctionPath}": ${zod_1.z.prettifyError(err)}`);
+            }
+            throw err;
+        }
+        logger?.debug(`Loaded local composite function "${compositeFunctionPath}" from ${path_1.default.relative(projectRoot, absolutePath)}`);
+        return config;
+    }
+    throw new Error(`Local composite function "${compositeFunctionPath}" was referenced by a step but no such composite function exists. A local composite function is resolved from a "function.yml" (or "function.yaml") file at the referenced path relative to the EAS project root (e.g. "uses: ${compositeFunctionPath}" resolves "${compositeFunctionPath}/function.yml"). The recommended convention is to keep composite functions under ".eas/functions/<name>".`);
+}
+function createCompositeFunctionLoader(projectRoot, logger) {
+    return compositeFunctionPath => loadLocalCompositeFunctionConfigAsync(projectRoot, compositeFunctionPath, { logger });
+}
+async function buildCompositeFunctionCatalogAsync(projectRoot, { steps, logger }) {
+    return (0, steps_1.buildCompositeFunctionCatalogFromStepsAsync)({
+        rootSteps: steps,
+        loadCompositeFunction: createCompositeFunctionLoader(projectRoot, logger),
+    });
+}

package/dist/steps/easFunctions.js

@@ -47,6 +47,8 @@ const startCuttlefishDevice_1 = require("./functions/startCuttlefishDevice");
 const startIosSimulator_1 = require("./functions/startIosSimulator");
 const startIosSimulatorRecordings_1 = require("./functions/startIosSimulatorRecordings");
 const startServeSimRemoteSession_1 = require("./functions/startServeSimRemoteSession");
+const startServeSimMetrics_1 = require("./functions/startServeSimMetrics");
+const collectServeSimMetrics_1 = require("./functions/collectServeSimMetrics");
 const uploadArtifact_1 = require("./functions/uploadArtifact");
 const uploadDeviceRunSessionScreenRecordings_1 = require("./functions/uploadDeviceRunSessionScreenRecordings");
 const uploadToAsc_1 = require("./functions/uploadToAsc");
@@ -95,6 +97,8 @@ function getEasFunctions(ctx) {
         (0, finishIosSimulatorRecordings_1.createFinishIosSimulatorRecordingsBuildFunction)(),
         (0, uploadDeviceRunSessionScreenRecordings_1.createUploadDeviceRunSessionScreenRecordingsBuildFunction)(ctx),
         (0, startServeSimRemoteSession_1.createStartServeSimRemoteSessionBuildFunction)(ctx),
+        (0, startServeSimMetrics_1.createStartServeSimMetricsBuildFunction)(),
+        (0, collectServeSimMetrics_1.createCollectServeSimMetricsBuildFunction)(ctx),
         (0, installMaestro_1.createInstallMaestroBuildFunction)(),
         (0, installPods_1.createInstallPodsBuildFunction)(),
         (0, sendSlackMessage_1.createSendSlackMessageFunction)(),

package/dist/steps/functions/checkout.js

@@ -4,8 +4,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createCheckoutBuildFunction = createCheckoutBuildFunction;
+const eas_build_job_1 = require("@expo/eas-build-job");
 const steps_1 = require("@expo/steps");
 const fs_extra_1 = __importDefault(require("fs-extra"));
+const zod_1 = require("zod");
+const git_1 = require("../../common/git");
 function createCheckoutBuildFunction() {
     return new steps_1.BuildFunction({
         namespace: 'eas',
@@ -13,15 +16,37 @@ function createCheckoutBuildFunction() {
         name: 'Checkout',
         __metricsId: 'eas/checkout',
         __hookId: 'checkout',
-        fn: async (stepsCtx) => {
+        inputProviders: [
+            steps_1.BuildStepInput.createProvider({
+                id: 'ref',
+                required: false,
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.STRING,
+            }),
+        ],
+        fn: async (stepsCtx, { inputs }) => {
+            const ref = zod_1.z.string().min(1).optional().parse(inputs.ref.value);
             if (stepsCtx.global.wasCheckedOut()) {
+                if (ref) {
+                    throw new eas_build_job_1.UserError('EAS_CHECKOUT_REF_AFTER_CHECKOUT', `Project directory is already checked out, so the "ref" input (${ref}) would have no effect. Move this eas/checkout step before any other step that checks out the project (e.g. before eas/build).`);
+                }
                 stepsCtx.logger.info('Project directory is already checked out');
                 return;
             }
+            const archiveType = stepsCtx.global.staticContext.job.projectArchive.type;
+            if (ref && archiveType !== eas_build_job_1.ArchiveSourceType.GIT) {
+                throw new eas_build_job_1.UserError('EAS_CHECKOUT_REF_REQUIRES_GIT_SOURCES', `The "ref" input requires project sources to come from a git repository, e.g. a job triggered through the GitHub integration. It is not supported for local builds or uploaded project tarballs (this job's project archive type is "${archiveType}").`);
+            }
             stepsCtx.logger.info('Checking out project directory');
             await fs_extra_1.default.move(stepsCtx.global.projectSourceDirectory, stepsCtx.global.projectTargetDirectory, {
                 overwrite: true,
             });
+            if (ref) {
+                stepsCtx.logger.info(`Checking out ref "${ref}"`);
+                await (0, git_1.fetchAndCheckoutRefAsync)({
+                    ref,
+                    repositoryDirectory: stepsCtx.global.projectTargetDirectory,
+                });
+            }
             stepsCtx.global.markAsCheckedOut(stepsCtx.logger);
         },
     });

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

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

package/dist/steps/functions/collectServeSimMetrics.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCollectServeSimMetricsBuildFunction = createCollectServeSimMetricsBuildFunction;
+const steps_1 = require("@expo/steps");
+const sentry_1 = require("../../sentry");
+const remoteDeviceRunSession_1 = require("../utils/remoteDeviceRunSession");
+const serveSimMetricsArtifacts_1 = require("../utils/serveSimMetricsArtifacts");
+const serveSimMetricsRecorder_1 = require("../utils/serveSimMetricsRecorder");
+function createCollectServeSimMetricsBuildFunction(ctx) {
+    return new steps_1.BuildFunction({
+        namespace: 'eas',
+        id: 'collect_serve_sim_metrics',
+        name: 'Collect serve-sim metrics',
+        __metricsId: 'eas/collect_serve_sim_metrics',
+        supportedRuntimePlatforms: [steps_1.BuildRuntimePlatform.DARWIN],
+        fn: async ({ logger }, { env }) => {
+            const collected = await serveSimMetricsRecorder_1.ServeSimMetricsRecorder.finishAsync({ logger });
+            if (collected.length === 0) {
+                logger.info('No serve-sim metrics collected; skipping upload.');
+                return;
+            }
+            try {
+                const deviceRunSessionId = (0, remoteDeviceRunSession_1.getDeviceRunSessionIdOrThrow)(env);
+                for (const { udid, filePath, metadata } of collected) {
+                    await (0, serveSimMetricsArtifacts_1.uploadServeSimMetricsFileAsync)(ctx, {
+                        deviceRunSessionId,
+                        udid,
+                        filePath,
+                        metadata,
+                        logger,
+                    });
+                }
+            }
+            catch (err) {
+                const error = err instanceof Error ? err : new Error(String(err));
+                sentry_1.Sentry.capture('Could not upload serve-sim metrics', error);
+                logger.warn({ err: error }, 'Could not upload serve-sim metrics.');
+            }
+        },
+    });
+}

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

@@ -1,6 +1,7 @@
 import { type bunyan } from '@expo/logger';
 import { BuildFunction } from '@expo/steps';
 import { type CustomBuildContext } from '../../customBuildContext';
+export declare const DEFAULT_AGENT_DEVICE_VERSION = "0.20.3";
 export declare function createStartAgentDeviceRemoteSessionBuildFunction(ctx: CustomBuildContext): BuildFunction;
 export declare function stopAgentDeviceEventCollectionSafelyAsync({ eventCollection, deviceRunSessionId, logger, }: {
     eventCollection: {