@expo/build-tools 21.0.2 → 21.1.0

package/dist/steps/functions/maestroScreenshots.js

@@ -9,10 +9,18 @@ exports.computePureFailureFlowNames = computePureFailureFlowNames;
 exports.selectFailureScreenshots = selectFailureScreenshots;
 const promises_1 = __importDefault(require("fs/promises"));
 const path_1 = __importDefault(require("path"));
-// Maestro failure screenshot: `screenshot-[shard-N-]❌-<epochMillis>-(<flowName>).png`.
+// pre-v2.7.0 (Maestro <= 2.6.x): failure screenshots are flat files named
+// `screenshot-[shard-N-]❌-<epochMillis>-(<flowName>).png` directly in the session dir.
 // The flow name may contain parentheses, so anchor on the `-(` after the epoch and the
-// `).png` suffix rather than scanning for parens.
+// `).png` suffix rather than scanning for parens. Remove this path once the build fleet is
+// entirely on Maestro >= 2.7.0.
 const FAILURE_SCREENSHOT_PATTERN = /^screenshot-(?:shard-\d+-)?❌-(\d+)-\((.+)\)\.png$/u;
+// Maestro >= 2.7.0 bundle layout. Each flow gets its own dir under the session dir, with step
+// screenshots under `screenshots/` named `step-<NNN>-<slug>.png` (NNN is a 1-based, zero-padded
+// monotonic step sequence). Under the CLI (no `--analyze`) only failed/warned steps produce one.
+const STEP_SCREENSHOTS_DIRNAME = 'screenshots';
+const STEP_SCREENSHOT_PATTERN = /^step-(\d+)(?:-.*)?\.png$/;
+// pre-v2.7.0: parses the legacy flat failure-screenshot filename.
 function parseFailureScreenshotFilename(filename) {
     const match = filename.match(FAILURE_SCREENSHOT_PATTERN);
     if (!match) {
@@ -27,61 +35,186 @@ function parseFailureScreenshotFilename(filename) {
         capturedAtMs,
     };
 }
-// Scans every debug dir under testsDirectory whose mtime is recent enough (mtime-based to cover
-// the maestro <2.5.0 bug that splits one invocation across two dirs), then keeps only screenshots
-// whose own capturedAtMs is at/after capturedSinceMs. Never throws: an unreadable dir is logged
-// and skipped so a screenshot harvest can't affect the maestro step outcome.
+// Harvests one attempt's failure screenshots from the maestro debug output. Walks each session
+// dir under testsDirectory whose mtime is recent enough (mtime-based to also cover the maestro
+// <2.5.0 bug that splits one invocation across two dirs). Within a session dir, a child is either
+// a flat pre-v2.7.0 screenshot file or a Maestro >= 2.7.0 per-flow bundle dir — the single
+// structural seam below. Never throws: an unreadable dir/file is logged and skipped so a
+// screenshot harvest can't affect the maestro step outcome.
 async function harvestFailureScreenshotsAsync(args) {
     // Gate dirs by mtime floored to the second, so a dir created within the same second as the
-    // attempt start isn't stat'd below the baseline. The exact capturedAtMs gate below is what
+    // attempt start isn't stat'd below the baseline. The exact capturedAtMs gate per file is what
     // prevents mis-attributing an earlier attempt's screenshot.
     const dirSinceMtimeMs = Math.floor(args.capturedSinceMs / 1000) * 1000;
-    let entries;
+    // Bundle dir names already have '/' -> '_'; normalize the JUnit names the same way to match.
+    const normalizedFailedFlowNames = new Set([...args.failedFlowNames].map(normalizeFlowName));
+    let sessionEntries;
     try {
-        entries = await promises_1.default.readdir(args.testsDirectory, { withFileTypes: true });
+        sessionEntries = await promises_1.default.readdir(args.testsDirectory, { withFileTypes: true });
     }
     catch (err) {
         args.logger.info({ err }, `Skipping screenshot harvest: cannot read ${args.testsDirectory}.`);
         return [];
     }
-    const results = [];
-    for (const entry of entries) {
-        if (!entry.isDirectory()) {
+    const legacyShots = [];
+    const bundleShots = [];
+    for (const sessionEntry of sessionEntries) {
+        if (!sessionEntry.isDirectory()) {
             continue;
         }
-        const dirPath = path_1.default.join(args.testsDirectory, entry.name);
-        let filenames;
+        const sessionDir = path_1.default.join(args.testsDirectory, sessionEntry.name);
+        let children;
         try {
-            if ((await promises_1.default.stat(dirPath)).mtimeMs < dirSinceMtimeMs) {
+            if ((await promises_1.default.stat(sessionDir)).mtimeMs < dirSinceMtimeMs) {
                 continue;
             }
-            filenames = await promises_1.default.readdir(dirPath);
+            children = await promises_1.default.readdir(sessionDir, { withFileTypes: true });
         }
         catch (err) {
-            args.logger.info({ err }, `Skipping unreadable debug dir ${dirPath}.`);
+            args.logger.info({ err }, `Skipping unreadable debug dir ${sessionDir}.`);
             continue;
         }
-        for (const filename of filenames) {
-            const parsed = parseFailureScreenshotFilename(filename);
-            // Re-check capture time per file: a dir's mtime can advance after this attempt began (or
-            // fall within the floored-second dir baseline), so the dir gate alone would re-attribute an
-            // earlier attempt's screenshot to this one.
-            if (parsed === null || parsed.capturedAtMs < args.capturedSinceMs) {
-                continue;
+        for (const child of children) {
+            if (child.isDirectory()) {
+                // Maestro >= 2.7.0: a per-flow bundle dir.
+                const shot = await harvestFromBundleAsync({
+                    bundleDir: path_1.default.join(sessionDir, child.name),
+                    bundleName: child.name,
+                    normalizedFailedFlowNames,
+                    capturedSinceMs: args.capturedSinceMs,
+                    attemptIndex: args.attemptIndex,
+                    logger: args.logger,
+                });
+                if (shot !== null) {
+                    bundleShots.push(shot);
+                }
             }
-            results.push({
-                fileAbsPath: path_1.default.join(dirPath, filename),
-                displayName: `Failure Screenshot: ${parsed.flowName} (attempt ${args.attemptIndex + 1})`,
-                metadata: {
-                    kind: 'maestro-test-screenshot',
-                    flowName: parsed.flowName,
+            else {
+                // pre-v2.7.0: a flat failure screenshot file in the session dir.
+                const shot = harvestLegacyFlatShot({
+                    fileName: child.name,
+                    sessionDir,
+                    capturedSinceMs: args.capturedSinceMs,
                     attemptIndex: args.attemptIndex,
-                    capturedAtMs: parsed.capturedAtMs,
-                },
-            });
+                });
+                if (shot !== null) {
+                    legacyShots.push(shot);
+                }
+            }
+        }
+    }
+    // The website shows one screenshot per (flow, attempt). Two v2.7.0 bundle dirs can resolve to
+    // the same flow — a collision dir (`<flow>-2`) or a duplicate flow name — so keep the latest.
+    // Legacy shots need no dedupe: a flat filename is emitted once per failed flow, so there is no
+    // `<flow>-2` collision to collapse (and deduping them would change historical behavior).
+    return [...legacyShots, ...dedupeBundleShotsByFlowName(bundleShots)];
+}
+// Maestro >= 2.7.0: resolve a bundle dir to its owning failed flow and return that flow's failure
+// screenshot — the highest-numbered step in `screenshots/`. A required failure halts the flow, so
+// the failed step is normally the last (highest-numbered) captured step; earlier warned steps have
+// lower numbers. Best-effort limitation: without reading Maestro's per-command JSON we can't tell a
+// failed-step frame from a warned-step frame, so if the failing command captured nothing (e.g. a
+// non-visible command like runScript) but an earlier optional step warned, we return that warned
+// frame instead. Returns null when the bundle isn't a failed flow, its name is ambiguous, or it has
+// no usable step screenshot. Never throws.
+async function harvestFromBundleAsync(args) {
+    const flowName = resolveBundleFlowName(args.bundleName, args.normalizedFailedFlowNames);
+    if (flowName === null) {
+        return null;
+    }
+    const screenshotsDir = path_1.default.join(args.bundleDir, STEP_SCREENSHOTS_DIRNAME);
+    let filenames;
+    try {
+        filenames = await promises_1.default.readdir(screenshotsDir);
+    }
+    catch {
+        // No screenshots/ dir — e.g. the flow failed on a non-visible command, which captures none.
+        return null;
+    }
+    let best = null;
+    for (const filename of filenames) {
+        const match = filename.match(STEP_SCREENSHOT_PATTERN);
+        if (match === null) {
+            continue; // final.png and any non-step file
+        }
+        const stepIndex = Number(match[1]);
+        const fileAbsPath = path_1.default.join(screenshotsDir, filename);
+        let capturedAtMs;
+        try {
+            capturedAtMs = Math.round((await promises_1.default.stat(fileAbsPath)).mtimeMs);
+        }
+        catch (err) {
+            args.logger.info({ err }, `Skipping unreadable screenshot ${fileAbsPath}.`);
+            continue;
+        }
+        if (capturedAtMs < args.capturedSinceMs) {
+            continue; // a prior attempt's frame (bundle dir touched later than this attempt started)
+        }
+        if (best === null || stepIndex > best.stepIndex) {
+            best = { fileAbsPath, stepIndex, capturedAtMs };
+        }
+    }
+    if (best === null) {
+        return null;
+    }
+    return {
+        fileAbsPath: best.fileAbsPath,
+        displayName: `Failure Screenshot: ${flowName} (attempt ${args.attemptIndex + 1})`,
+        metadata: {
+            kind: 'maestro-test-screenshot',
+            flowName,
+            attemptIndex: args.attemptIndex,
+            capturedAtMs: best.capturedAtMs,
+        },
+    };
+}
+// Maestro names a bundle dir `<cleanFlow>` optionally + `-shard-<n>` (sharded) + `-<n>` (name
+// collision), where cleanFlow is the flow name with '/' -> '_'. Those suffixes share a namespace
+// with legitimate flow names, so we can't strip blindly (a flow may be named `x-shard-1` or `x-2`).
+// Enumerate the ways the dir name could peel back to a flow name, keep those that match a failed
+// flow, and use the result only if exactly one fits — otherwise skip rather than guess.
+function resolveBundleFlowName(bundleName, normalizedFailedFlowNames) {
+    const withoutCollision = bundleName.replace(/-\d+$/, '');
+    const preimages = [
+        bundleName,
+        withoutCollision,
+        withoutCollision.replace(/-shard-\d+$/, ''),
+        bundleName.replace(/-shard-\d+$/, ''),
+    ];
+    const matches = new Set(preimages.filter(name => normalizedFailedFlowNames.has(name)));
+    return matches.size === 1 ? [...matches][0] : null;
+}
+// Keep one screenshot per flow name (attemptIndex is constant within a harvest call), preferring
+// the latest capture when two bundles resolve to the same flow.
+function dedupeBundleShotsByFlowName(shots) {
+    const byFlowName = new Map();
+    for (const shot of shots) {
+        const existing = byFlowName.get(shot.metadata.flowName);
+        if (existing === undefined || shot.metadata.capturedAtMs > existing.metadata.capturedAtMs) {
+            byFlowName.set(shot.metadata.flowName, shot);
         }
     }
-    return results;
+    return [...byFlowName.values()];
+}
+// pre-v2.7.0 (Maestro <= 2.6.x) reader: a flat `screenshot-...❌...png` file whose name carries the
+// flow name and capture epoch.
+function harvestLegacyFlatShot(args) {
+    const parsed = parseFailureScreenshotFilename(args.fileName);
+    // Re-check capture time per file — a dir's mtime can advance after this attempt began, so the dir
+    // gate alone would re-attribute an earlier attempt's screenshot to this one.
+    if (parsed === null || parsed.capturedAtMs < args.capturedSinceMs) {
+        return null;
+    }
+    return {
+        fileAbsPath: path_1.default.join(args.sessionDir, args.fileName),
+        displayName: `Failure Screenshot: ${parsed.flowName} (attempt ${args.attemptIndex + 1})`,
+        metadata: {
+            kind: 'maestro-test-screenshot',
+            flowName: parsed.flowName,
+            attemptIndex: args.attemptIndex,
+            capturedAtMs: parsed.capturedAtMs,
+        },
+    };
 }
 // Maestro substitutes '/' -> '_' in screenshot filenames (so HarvestedScreenshot.flowName
 // is already in that form) but keeps '/' in the JUnit testcase name. Normalize the JUnit

package/dist/steps/functions/maestroTests.js

@@ -216,10 +216,14 @@ function createMaestroTestsBuildFunction(ctx) {
                 // junit: test-case-result rows (and therefore the summary icons) only exist for junit
                 // runs, so harvesting other formats would just create orphan artifacts the website hides.
                 if (outputFormat === 'junit') {
+                    const failedFlowNames = outputPath
+                        ? await (0, maestroResultParser_1.parseFailedFlowNamesFromJUnitFile)(outputPath)
+                        : new Set();
                     harvested.push(...(await (0, maestroScreenshots_1.harvestFailureScreenshotsAsync)({
                         testsDirectory,
                         capturedSinceMs: attemptStartedAtMs,
                         attemptIndex: attempt,
+                        failedFlowNames,
                         logger,
                     })));
                 }

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

@@ -1,3 +1,11 @@
+import { type bunyan } from '@expo/logger';
 import { BuildFunction } from '@expo/steps';
 import { type CustomBuildContext } from '../../customBuildContext';
 export declare function createStartAgentDeviceRemoteSessionBuildFunction(ctx: CustomBuildContext): BuildFunction;
+export declare function stopAgentDeviceEventCollectionSafelyAsync({ eventCollection, deviceRunSessionId, logger, }: {
+    eventCollection: {
+        stopAsync: () => Promise<void>;
+    };
+    deviceRunSessionId: string;
+    logger: bunyan;
+}): Promise<void>;

package/dist/steps/functions/startAgentDeviceRemoteSession.js

@@ -4,6 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createStartAgentDeviceRemoteSessionBuildFunction = createStartAgentDeviceRemoteSessionBuildFunction;
+exports.stopAgentDeviceEventCollectionSafelyAsync = stopAgentDeviceEventCollectionSafelyAsync;
 const eas_build_job_1 = require("@expo/eas-build-job");
 const steps_1 = require("@expo/steps");
 const turtle_spawn_1 = __importDefault(require("@expo/turtle-spawn"));
@@ -12,11 +13,13 @@ const node_os_1 = __importDefault(require("node:os"));
 const node_path_1 = __importDefault(require("node:path"));
 const sentry_1 = require("../../sentry");
 const agentDeviceArtifacts_1 = require("../utils/agentDeviceArtifacts");
+const deviceRunSessionEvents_1 = require("../utils/deviceRunSessionEvents");
 const remoteDeviceRunSession_1 = require("../utils/remoteDeviceRunSession");
 const AGENT_DEVICE_PACKAGE_NAME = 'agent-device';
 const AGENT_DEVICE_REPO_URL = 'https://github.com/callstack/agent-device.git';
 const SRC_DIR = '/tmp/agent-device-src';
-const DAEMON_JSON_PATH = node_path_1.default.join(node_os_1.default.homedir(), '.agent-device', 'daemon.json');
+const AGENT_DEVICE_STATE_DIR = node_path_1.default.join(node_os_1.default.homedir(), '.agent-device');
+const DAEMON_JSON_PATH = node_path_1.default.join(AGENT_DEVICE_STATE_DIR, 'daemon.json');
 const STARTUP_TIMEOUT_MS = 60_000;
 const AGENT_DEVICE_DAEMON_ENV = {
     AGENT_DEVICE_DAEMON_SERVER_MODE: 'http',
@@ -93,15 +96,44 @@ function createStartAgentDeviceRemoteSessionBuildFunction(ctx) {
                 daemonToken,
                 logger,
             });
-            await (0, remoteDeviceRunSession_1.waitForDeviceRunSessionStoppedAsync)({
+            const eventCollection = await (0, deviceRunSessionEvents_1.startAgentDeviceEventCollectionAsync)({
                 ctx,
                 deviceRunSessionId,
+                stateDir: AGENT_DEVICE_STATE_DIR,
                 logger,
-                signal,
             });
+            try {
+                await (0, remoteDeviceRunSession_1.waitForDeviceRunSessionStoppedAsync)({
+                    ctx,
+                    deviceRunSessionId,
+                    logger,
+                    signal,
+                });
+            }
+            finally {
+                await stopAgentDeviceEventCollectionSafelyAsync({
+                    eventCollection,
+                    deviceRunSessionId,
+                    logger,
+                });
+            }
         },
     });
 }
+async function stopAgentDeviceEventCollectionSafelyAsync({ eventCollection, deviceRunSessionId, logger, }) {
+    try {
+        await eventCollection.stopAsync();
+    }
+    catch (err) {
+        const error = err instanceof Error ? err : new Error(String(err));
+        sentry_1.Sentry.capture('Could not finish agent-device session event collection', error, {
+            level: 'warning',
+            tags: { phase: 'agent-device-event-collection', operation: 'stop' },
+            extras: { deviceRunSessionId },
+        });
+        logger.warn({ err: error }, 'Could not finish agent-device session event collection.');
+    }
+}
 async function startAgentDeviceDaemonAsync({ packageVersion, env, logger, }) {
     const packageSpec = createAgentDevicePackageSpec(packageVersion);
     try {

package/dist/steps/utils/deviceRunSessionEvents.d.ts

@@ -0,0 +1,23 @@
+import { type bunyan } from '@expo/logger';
+import { type CustomBuildContext } from '../../customBuildContext';
+export type DeviceRunSessionEvent = {
+    v: 1;
+    eventId: string;
+    ts: string;
+    producer: string;
+    type: string;
+    operationId?: string;
+    outcome?: 'success' | 'failure';
+    durationMs?: number;
+    summary: string;
+    data?: Record<string, unknown>;
+};
+export declare function startAgentDeviceEventCollectionAsync({ ctx, deviceRunSessionId, stateDir, logger, pollIntervalMs, }: {
+    ctx: CustomBuildContext;
+    deviceRunSessionId: string;
+    stateDir: string;
+    logger: bunyan;
+    pollIntervalMs?: number;
+}): Promise<{
+    stopAsync: () => Promise<void>;
+}>;