@expo/build-tools 21.0.1 → 21.0.3

package/dist/builders/android.js

@@ -41,7 +41,18 @@ async function androidBuilder(ctx) {
     }
 }
 async function buildAsync(ctx) {
-    await (0, setup_1.setupAsync)(ctx);
+    const jobHooksRef = { current: null };
+    try {
+        await buildInnerAsync(ctx, jobHooksRef);
+    }
+    finally {
+        // Native builds have no other drain path for the hook context's queued
+        // step-metric uploads.
+        await jobHooksRef.current?.customBuildContext.drainPendingMetricUploads();
+    }
+}
+async function buildInnerAsync(ctx, jobHooksRef) {
+    await (0, setup_1.setupAsync)(ctx, { wrappedAnchors: ['install_node_modules'], jobHooksRef });
     const evictUsedBefore = new Date();
     const workingDirectory = ctx.getReactNativeProjectDirectory();
     const hasNativeCode = ctx.job.type === eas_build_job_1.Workflow.GENERIC;

package/dist/builders/ios.js

@@ -50,7 +50,19 @@ async function iosBuilder(ctx) {
     }
 }
 async function buildAsync(ctx) {
-    await (0, setup_1.setupAsync)(ctx);
+    const jobHooksRef = { current: null };
+    try {
+        await buildInnerAsync(ctx, jobHooksRef);
+    }
+    finally {
+        // Native builds have no other drain path for the hook context's queued
+        // step-metric uploads. Must wrap the WHOLE body — iOS's existing inner
+        // try/finally only starts after setupAsync returns.
+        await jobHooksRef.current?.customBuildContext.drainPendingMetricUploads();
+    }
+}
+async function buildInnerAsync(ctx, jobHooksRef) {
+    await (0, setup_1.setupAsync)(ctx, { wrappedAnchors: ['install_node_modules'], jobHooksRef });
     const hasNativeCode = ctx.job.type === eas_build_job_1.Workflow.GENERIC;
     const evictUsedBefore = new Date();
     const credentialsManager = new manager_1.default(ctx);

package/dist/common/easBuildInternal.js

@@ -111,6 +111,9 @@ function validateEasBuildInternalResult({ oldJob, result, }) {
         // We want to retain values that we have set on the job.
         appId: oldJob.appId,
         initiatingUserId: oldJob.initiatingUserId,
+        // Hooks are resolved server-side at submit; the mid-build eas.json
+        // regeneration must not add, drop, or change them (the original wins).
+        hooks: oldJob.hooks,
         ...(oldJob.platform === eas_build_job_1.Platform.IOS && oldJob.refreshAdHocProvisioningProfile === true
             ? { refreshAdHocProvisioningProfile: true }
             : null),

package/dist/common/hookableBuildPhase.d.ts

@@ -0,0 +1,18 @@
+import { BuildJob, BuildPhase, HookAnchorId } from '@expo/eas-build-job';
+import { BuildContext } from '../context';
+import { ParsedJobHooks } from './jobHooks';
+/**
+ * Runs a native build phase with its `before_<anchor>` / `after_<anchor>` hooks
+ * wrapped around it: before-entries -> phase (in a try) -> after-entries, with
+ * after-on-failure guaranteed. A failing before sequence skips the phase AND the
+ * after-hooks (steps-engine parity). The phase error always wins over an
+ * after-hook error. Passthrough (no hooks or no keys for this anchor) runs the
+ * phase exactly once with zero overhead.
+ */
+export declare function runHookableBuildPhaseAsync<TJob extends BuildJob, T>({ ctx, hooks, buildPhase, anchor, fn, }: {
+    ctx: BuildContext<TJob>;
+    hooks: ParsedJobHooks | null;
+    buildPhase: BuildPhase;
+    anchor: HookAnchorId;
+    fn: () => Promise<T>;
+}): Promise<T>;

package/dist/common/hookableBuildPhase.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runHookableBuildPhaseAsync = runHookableBuildPhaseAsync;
+const eas_build_job_1 = require("@expo/eas-build-job");
+const steps_1 = require("@expo/steps");
+/**
+ * Runs a native build phase with its `before_<anchor>` / `after_<anchor>` hooks
+ * wrapped around it: before-entries -> phase (in a try) -> after-entries, with
+ * after-on-failure guaranteed. A failing before sequence skips the phase AND the
+ * after-hooks (steps-engine parity). The phase error always wins over an
+ * after-hook error. Passthrough (no hooks or no keys for this anchor) runs the
+ * phase exactly once with zero overhead.
+ */
+async function runHookableBuildPhaseAsync({ ctx, hooks, buildPhase, anchor, fn, }) {
+    // runHookEntriesAsync no-ops when the key has no entries.
+    if (hooks) {
+        await runHookEntriesAsync({ ctx, hooks, timing: 'before', anchor });
+    }
+    let result;
+    try {
+        result = await ctx.runBuildPhase(buildPhase, fn);
+    }
+    catch (phaseError) {
+        if (hooks) {
+            try {
+                await runHookEntriesAsync({ ctx, hooks, timing: 'after', anchor, anchorFailed: true });
+            }
+            catch (hookError) {
+                // The phase error wins; still surface the after-hook failure in the log.
+                ctx.logger.error({ err: hookError }, `after_${anchor} hook failed`);
+            }
+        }
+        throw phaseError;
+    }
+    if (hooks) {
+        await runHookEntriesAsync({ ctx, hooks, timing: 'after', anchor, anchorFailed: false });
+    }
+    return result;
+}
+async function runHookEntriesAsync({ ctx, hooks, timing, anchor, anchorFailed = false, }) {
+    const hookKey = `${timing}_${anchor}`;
+    const entries = hooks.hookEntriesByKey[hookKey];
+    if (!entries?.length) {
+        return;
+    }
+    // Refresh the hook context from the live BuildContext before running: env
+    // moves as the build runs (set-env written back below; profile env), and
+    // job/metadata are replaced by eas build:internal.
+    hooks.customBuildContext.updateEnv(ctx.env);
+    // Overwrite the job/metadata snapshot; NOT updateJobInformation, whose
+    // delta-merge would duplicate environmentSecrets on each refresh.
+    hooks.customBuildContext.job = ctx.job;
+    hooks.customBuildContext.metadata = ctx.metadata;
+    if (timing === 'after' && anchorFailed) {
+        // Mirror the engine: the anchor's failure is marked on the shared context so
+        // `failure()` / `success()` on after-hook steps read the phase outcome.
+        hooks.globalContext.markAsFailed();
+    }
+    const { failedLocally, firstError } = await (0, steps_1.executeHookStepsAsync)(hooks.globalContext, entries, {
+        anchor,
+        timing,
+        ...(timing === 'after' ? { anchorResult: anchorFailed ? 'failed' : 'success' } : null),
+    });
+    // Reverse write-back BEFORE propagating a failure: env set by the entries that
+    // did run must reach the build context even when a later entry failed, so the
+    // native phases (and the outer lifecycle hooks) see it. Hook-carrying builds
+    // are git-based, so updateEnv's gate does not fire here.
+    ctx.updateEnv(hooks.globalContext.env);
+    if (failedLocally) {
+        throw new eas_build_job_1.UserError(eas_build_job_1.ErrorCode.HOOKS_ERROR, `Hook "${hookKey}" failed: ${firstError instanceof Error ? firstError.message : String(firstError)}. Check the failing hook step's logs above.`, { cause: firstError });
+    }
+}

package/dist/common/jobHooks.d.ts

@@ -0,0 +1,16 @@
+import { BuildJob, HookAnchorId, HookKey } from '@expo/eas-build-job';
+import { BuildStepGlobalContext, HookEntry } from '@expo/steps';
+import { BuildContext } from '../context';
+import { CustomBuildContext } from '../customBuildContext';
+export interface ParsedJobHooks {
+    globalContext: BuildStepGlobalContext;
+    customBuildContext: CustomBuildContext;
+    hookEntriesByKey: Partial<Record<HookKey, HookEntry[]>>;
+}
+/**
+ * Parses the native job's `hooks` into engine-ready entries, once, at setup
+ * time. Shape-validates every registered key (reachable or not); constructs
+ * entries only for the anchors this build actually wraps. Returns null when the
+ * job declares no hooks.
+ */
+export declare function parseJobHooksAsync<TJob extends BuildJob>(ctx: BuildContext<TJob>, wrappedAnchors: readonly HookAnchorId[]): Promise<ParsedJobHooks | null>;

package/dist/common/jobHooks.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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 easFunctionGroups_1 = require("../steps/easFunctionGroups");
+const easFunctions_1 = require("../steps/easFunctions");
+/**
+ * Parses the native job's `hooks` into engine-ready entries, once, at setup
+ * time. Shape-validates every registered key (reachable or not); constructs
+ * entries only for the anchors this build actually wraps. Returns null when the
+ * job declares no hooks.
+ */
+async function parseJobHooksAsync(ctx, wrappedAnchors) {
+    const hooks = ctx.job.hooks;
+    if (!hooks || Object.keys(hooks).length === 0) {
+        return null;
+    }
+    const customBuildContext = new customBuildContext_1.CustomBuildContext(ctx);
+    const globalContext = new steps_1.BuildStepGlobalContext(customBuildContext, false);
+    // Hook steps run in the checked-out project directory, not the pre-checkout
+    // target directory the global context defaults to.
+    globalContext.markAsCheckedOut(ctx.logger);
+    const externalFunctions = (0, easFunctions_1.getEasFunctions)(customBuildContext);
+    const externalFunctionGroups = (0, easFunctionGroups_1.getEasFunctionGroups)(customBuildContext);
+    // Shape-validate every REGISTERED key, reachable or not (steps-world parity:
+    // a malformed `before_submit` fails a steps build, so it fails here too), and
+    // warn on keys this build won't run. An unknown key is inert — a key newer
+    // than this worker must be ignored, never fail the job.
+    for (const [key, steps] of Object.entries(hooks)) {
+        const parsed = (0, eas_build_job_1.parseHookKey)(key);
+        if (parsed === null) {
+            ctx.logger.warn(`Ignoring unknown hook key "${key}".`);
+            continue;
+        }
+        if (Array.isArray(steps) && steps.length === 0) {
+            // `[]` is an explicit opt-out; validateSteps requires >= 1 step.
+            continue;
+        }
+        try {
+            (0, eas_build_job_1.validateSteps)(steps);
+        }
+        catch (err) {
+            throw new eas_build_job_1.UserError(eas_build_job_1.ErrorCode.HOOKS_ERROR, `Invalid steps in "hooks.${key}": ${err instanceof Error ? err.message : String(err)}`, { cause: err });
+        }
+        // Registered but not wrapped by this build: shape-checked above, then
+        // skipped. Function existence is deliberately NOT checked (that happens only
+        // during construction) — an unknown `uses:` under an unwrapped key warns
+        // rather than failing the build.
+        if (!wrappedAnchors.includes(parsed.anchorId)) {
+            ctx.logger.warn(`Ignoring "hooks.${key}": this build does not run the "${parsed.anchorId}" step.`);
+        }
+    }
+    // Construct entries for the wrapped anchors in EXECUTION order (per anchor,
+    // before_ then after_) so generated step ids and output references follow the
+    // order steps actually run. All entries share one globalContext, so env and
+    // outputs accumulate across keys.
+    const hookEntriesByKey = {};
+    const orderedSteps = [];
+    for (const anchor of wrappedAnchors) {
+        for (const side of ['before', 'after']) {
+            const key = `${side}_${anchor}`;
+            const steps = hooks[key];
+            if (!Array.isArray(steps) || steps.length === 0) {
+                continue;
+            }
+            let entries;
+            try {
+                entries = await (0, steps_1.constructHookEntriesAsync)(globalContext, steps, {
+                    externalFunctions,
+                    externalFunctionGroups,
+                });
+            }
+            catch (err) {
+                throw new eas_build_job_1.UserError(eas_build_job_1.ErrorCode.HOOKS_ERROR, `Failed to parse hooks.${key}: ${err instanceof Error ? err.message : String(err)}. Hooks use the same syntax as workflow steps.`, { cause: err });
+            }
+            hookEntriesByKey[key] = entries;
+            for (const entry of entries) {
+                orderedSteps.push(...entry.steps);
+            }
+        }
+    }
+    // One aggregate pass over every constructed step in execution order: unique
+    // ids, output references, and platform allowance. Per-key validation misses
+    // cross-key id collisions and would reject a legal after -> before output
+    // reference as a future reference.
+    try {
+        await (0, steps_1.validateHookStepsAsync)(globalContext, orderedSteps);
+    }
+    catch (err) {
+        throw new eas_build_job_1.UserError(eas_build_job_1.ErrorCode.HOOKS_ERROR, `The job's hooks are invalid: ${err instanceof Error ? err.message : String(err)}. Fix the reported step ids or output references.`, { cause: err });
+    }
+    return { globalContext, customBuildContext, hookEntriesByKey };
+}

package/dist/common/setup.d.ts

@@ -1,3 +1,15 @@
-import { BuildJob } from '@expo/eas-build-job';
+import { BuildJob, HookAnchorId } from '@expo/eas-build-job';
+import { ParsedJobHooks } from './jobHooks';
 import { BuildContext } from '../context';
-export declare function setupAsync<TJob extends BuildJob>(ctx: BuildContext<TJob>): Promise<void>;
+/**
+ * Mutable holder the builder passes into setupAsync. setupAsync assigns
+ * `current` the moment hooks are parsed (before any hook runs), so the builder's
+ * finally can drain queued metric uploads even if setup fails partway through.
+ */
+export interface JobHooksRef {
+    current: ParsedJobHooks | null;
+}
+export declare function setupAsync<TJob extends BuildJob>(ctx: BuildContext<TJob>, { wrappedAnchors, jobHooksRef, }: {
+    wrappedAnchors: readonly HookAnchorId[];
+    jobHooksRef: JobHooksRef;
+}): Promise<void>;

package/dist/common/setup.js

@@ -10,7 +10,9 @@ const fs_extra_1 = __importDefault(require("fs-extra"));
 const nullthrows_1 = __importDefault(require("nullthrows"));
 const path_1 = __importDefault(require("path"));
 const easBuildInternal_1 = require("./easBuildInternal");
+const hookableBuildPhase_1 = require("./hookableBuildPhase");
 const installDependencies_1 = require("./installDependencies");
+const jobHooks_1 = require("./jobHooks");
 const projectSources_1 = require("./projectSources");
 const xcodeEnv_1 = require("../ios/xcodeEnv");
 const hooks_1 = require("../utils/hooks");
@@ -26,7 +28,7 @@ class DoctorTimeoutError extends Error {
 }
 class InstallDependenciesTimeoutError extends Error {
 }
-async function setupAsync(ctx) {
+async function setupAsync(ctx, { wrappedAnchors, jobHooksRef, }) {
     await ctx.runBuildPhase(eas_build_job_1.BuildPhase.PREPARE_PROJECT, async () => {
         await (0, retry_1.retryAsync)(async () => {
             await fs_extra_1.default.rm(ctx.buildDirectory, { recursive: true, force: true });
@@ -64,27 +66,42 @@ async function setupAsync(ctx) {
             ctx.logger.error({ err }, `Failed to read eas.json.`);
         }
     });
-    const packageJson = await ctx.runBuildPhase(eas_build_job_1.BuildPhase.READ_PACKAGE_JSON, async () => {
-        return (0, project_1.readAndLogPackageJson)(ctx.logger, ctx.getReactNativeProjectDirectory());
+    await ctx.runBuildPhase(eas_build_job_1.BuildPhase.READ_PACKAGE_JSON, async () => {
+        (0, project_1.readAndLogPackageJson)(ctx.logger, ctx.getReactNativeProjectDirectory());
     });
-    await ctx.runBuildPhase(eas_build_job_1.BuildPhase.INSTALL_DEPENDENCIES, async () => {
-        const expoVersion = ctx.metadata?.sdkVersion ??
-            (0, packageManager_1.getPackageVersionFromPackageJson)({
-                packageJson,
-                packageName: 'expo',
+    // Parse hooks unconditionally, after every pre-install env mutation
+    // (PREPARE_PROJECT, the git-based profile-env block, PRE_INSTALL_HOOK) and
+    // before the first wrapped phase.
+    jobHooksRef.current = await (0, jobHooks_1.parseJobHooksAsync)(ctx, wrappedAnchors);
+    await (0, hookableBuildPhase_1.runHookableBuildPhaseAsync)({
+        ctx,
+        hooks: jobHooksRef.current,
+        buildPhase: eas_build_job_1.BuildPhase.INSTALL_DEPENDENCIES,
+        anchor: 'install_node_modules',
+        fn: async () => {
+            // Read package.json fresh here rather than reusing the READ_PACKAGE_JSON
+            // capture: a before_install_node_modules hook may have patched it, and the
+            // steps-world install already reads it fresh. Silent read — READ_PACKAGE_JSON
+            // stays the only logging site.
+            const freshPackageJson = (0, project_1.readPackageJson)(ctx.getReactNativeProjectDirectory());
+            const expoVersion = ctx.metadata?.sdkVersion ??
+                (0, packageManager_1.getPackageVersionFromPackageJson)({
+                    packageJson: freshPackageJson,
+                    packageName: 'expo',
+                });
+            const reactNativeVersion = ctx.metadata?.reactNativeVersion ??
+                (0, packageManager_1.getPackageVersionFromPackageJson)({
+                    packageJson: freshPackageJson,
+                    packageName: 'react-native',
+                });
+            await runInstallDependenciesAsync(ctx, {
+                useFrozenLockfile: (0, packageManager_1.shouldUseFrozenLockfile)({
+                    env: ctx.env,
+                    sdkVersion: expoVersion,
+                    reactNativeVersion,
+                }),
             });
-        const reactNativeVersion = ctx.metadata?.reactNativeVersion ??
-            (0, packageManager_1.getPackageVersionFromPackageJson)({
-                packageJson,
-                packageName: 'react-native',
-            });
-        await runInstallDependenciesAsync(ctx, {
-            useFrozenLockfile: (0, packageManager_1.shouldUseFrozenLockfile)({
-                env: ctx.env,
-                sdkVersion: expoVersion,
-                reactNativeVersion,
-            }),
-        });
+        },
     });
     await ctx.runBuildPhase(eas_build_job_1.BuildPhase.READ_APP_CONFIG, async () => {
         const appConfig = await ctx.appConfig;
@@ -111,7 +128,9 @@ async function setupAsync(ctx) {
             ctx.updateJobInformation(newJob, newMetadata);
         });
     }
-    const hasExpoPackage = !!packageJson.dependencies?.expo;
+    // Read fresh: a before_install_node_modules hook may have added or removed
+    // the expo dependency.
+    const hasExpoPackage = !!(0, project_1.readPackageJson)(ctx.getReactNativeProjectDirectory()).dependencies?.expo;
     if (!ctx.env.EAS_BUILD_DISABLE_EXPO_DOCTOR_STEP && hasExpoPackage) {
         await ctx.runBuildPhase(eas_build_job_1.BuildPhase.RUN_EXPO_DOCTOR, async () => {
             try {

package/dist/context.js

@@ -17,26 +17,6 @@ const packageManager_1 = require("./utils/packageManager");
 class SkipNativeBuildError extends Error {
 }
 exports.SkipNativeBuildError = SkipNativeBuildError;
-function logEnvComparison({ oldMergeOrderEnv, newMergeOrderEnv, }) {
-    const envNames = new Set([...Object.keys(oldMergeOrderEnv), ...Object.keys(newMergeOrderEnv)]);
-    const sameEnvNames = [];
-    const differentEnvNames = [];
-    for (const key of envNames) {
-        const hasOldValue = key in oldMergeOrderEnv;
-        const hasNewValue = key in newMergeOrderEnv;
-        if (hasOldValue === hasNewValue && oldMergeOrderEnv[key] === newMergeOrderEnv[key]) {
-            sameEnvNames.push(key);
-        }
-        else {
-            differentEnvNames.push(key);
-        }
-    }
-    if (differentEnvNames.length === 0) {
-        datadog_1.Datadog.log('BuildContext.updateEnv merge order produced same env');
-        return;
-    }
-    datadog_1.Datadog.log(`BuildContext.updateEnv merge order produced different env: compared_env_count=${envNames.size} different_env_count=${differentEnvNames.length} different_env_names=${differentEnvNames.join(',')} same_env_count=${sameEnvNames.length} same_env_names=${sameEnvNames.join(',')}`);
-}
 class BuildContext {
     workingdir;
     logger;
@@ -177,21 +157,11 @@ class BuildContext {
         if (this._job.triggeredBy !== common_1.BuildTrigger.GIT_BASED_INTEGRATION) {
             throw new Error('Updating environment variables is only allowed when build was triggered by a git-based integration.');
         }
-        const oldMergeOrderEnv = {
-            ...env,
-            ...this._env,
-            __EAS_BUILD_ENVS_DIR: this.buildEnvsDirectory,
-        };
-        const newMergeOrderEnv = {
+        this._env = {
             ...this._env,
             ...env,
             __EAS_BUILD_ENVS_DIR: this.buildEnvsDirectory,
         };
-        logEnvComparison({
-            oldMergeOrderEnv,
-            newMergeOrderEnv,
-        });
-        this._env = newMergeOrderEnv;
         this._env.PATH = this._env.PATH
             ? [this.buildExecutablesDirectory, this._env.PATH].join(':')
             : this.buildExecutablesDirectory;

package/dist/index.d.ts

@@ -1,7 +1,8 @@
 import * as Builders from './builders';
-import GCSLoggerStream from './gcs/LoggerStream';
-import GCS from './gcs/client';
-export { Builders, GCS, GCSLoggerStream };
+import RemoteLoggerStream from './logging/RemoteLoggerStream';
+export { Builders, RemoteLoggerStream };
+export { uploadWithSignedUrl } from './storage/uploadWithSignedUrl';
+export type { SignedUrl, UploadWithSignedUrlParams } from './storage/uploadWithSignedUrl';
 export { ArtifactToUpload, Artifacts, BuildContext, BuildContextOptions, CacheManager, LogBuffer, SkipNativeBuildError, } from './context';
 export { PackageManager } from './utils/packageManager';
 export { findAndUploadXcodeBuildLogsAsync } from './ios/xcodeBuildLogs';

package/dist/index.js

@@ -39,13 +39,13 @@ 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.GCSLoggerStream = exports.GCS = 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.Builders = void 0;
 const Builders = __importStar(require("./builders"));
 exports.Builders = Builders;
-const LoggerStream_1 = __importDefault(require("./gcs/LoggerStream"));
-exports.GCSLoggerStream = LoggerStream_1.default;
-const client_1 = __importDefault(require("./gcs/client"));
-exports.GCS = client_1.default;
+const RemoteLoggerStream_1 = __importDefault(require("./logging/RemoteLoggerStream"));
+exports.RemoteLoggerStream = RemoteLoggerStream_1.default;
+var uploadWithSignedUrl_1 = require("./storage/uploadWithSignedUrl");
+Object.defineProperty(exports, "uploadWithSignedUrl", { enumerable: true, get: function () { return uploadWithSignedUrl_1.uploadWithSignedUrl; } });
 var context_1 = require("./context");
 Object.defineProperty(exports, "BuildContext", { enumerable: true, get: function () { return context_1.BuildContext; } });
 Object.defineProperty(exports, "SkipNativeBuildError", { enumerable: true, get: function () { return context_1.SkipNativeBuildError; } });

package/dist/{gcs/LoggerStream.d.ts → logging/RemoteLoggerStream.d.ts}

@@ -1,7 +1,7 @@
 import { bunyan } from '@expo/logger';
 import { Writable } from 'stream';
-import GCS from './client';
-declare class GCSLoggerStream extends Writable {
+import { type SignedUrl } from '../storage/uploadWithSignedUrl';
+declare class RemoteLoggerStream extends Writable {
     writable: boolean;
     private readonly logger;
     private readonly uploadMethod?;
@@ -16,7 +16,7 @@ declare class GCSLoggerStream extends Writable {
     private buffer;
     private writePromise?;
     private cleanUpCalled;
-    constructor({ logger, uploadMethod, options }: GCSLoggerStream.Config);
+    constructor({ logger, uploadMethod, options }: RemoteLoggerStream.Config);
     private findNormalizedHeader;
     init(): Promise<string>;
     cleanUp(): Promise<void>;
@@ -27,7 +27,7 @@ declare class GCSLoggerStream extends Writable {
     private upload;
     private createCompressedStream;
 }
-declare namespace GCSLoggerStream {
+declare namespace RemoteLoggerStream {
     enum CompressionMethod {
         GZIP = "gzip",
         BR = "br"
@@ -37,11 +37,7 @@ declare namespace GCSLoggerStream {
         compress?: CompressionMethod;
     }
     type UploadMethod = {
-        client: GCS;
-        key: string;
-        customTime: Date | null;
-    } | {
-        signedUrl: GCS.SignedUrl;
+        signedUrl: SignedUrl;
     };
     interface Config {
         logger: bunyan;
@@ -49,4 +45,4 @@ declare namespace GCSLoggerStream {
         options: Options;
     }
 }
-export default GCSLoggerStream;
+export default RemoteLoggerStream;

package/dist/{gcs/LoggerStream.js → logging/RemoteLoggerStream.js}

@@ -11,9 +11,9 @@ const path_1 = __importDefault(require("path"));
 const stream_1 = require("stream");
 const util_1 = require("util");
 const zlib_1 = __importDefault(require("zlib"));
-const client_1 = __importDefault(require("./client"));
+const uploadWithSignedUrl_1 = require("../storage/uploadWithSignedUrl");
 const pipe = (0, util_1.promisify)(stream_1.pipeline);
-class GCSLoggerStream extends stream_1.Writable {
+class RemoteLoggerStream extends stream_1.Writable {
     writable = true;
     logger;
     uploadMethod;
@@ -38,7 +38,7 @@ class GCSLoggerStream extends stream_1.Writable {
         this.temporaryCompressedLogsPath = `${this.temporaryLogsPath}.compressed`;
     }
     findNormalizedHeader(name) {
-        if (!this.uploadMethod || 'client' in this.uploadMethod) {
+        if (!this.uploadMethod) {
             return null;
         }
         const normalizedName = name.toLowerCase().replace('-', '');
@@ -74,7 +74,7 @@ class GCSLoggerStream extends stream_1.Writable {
         await this.flush(true);
         await fs_extra_1.default.remove(this.temporaryLogsPath);
         await fs_extra_1.default.remove(this.temporaryCompressedLogsPath);
-        this.logger.info('Cleaning up GCS log stream');
+        this.logger.info('Cleaning up log stream');
     }
     write(rec) {
         if (!this.fileHandle) {
@@ -102,7 +102,7 @@ class GCSLoggerStream extends stream_1.Writable {
             this.hasChangesToUpload = true;
         }
         catch (err) {
-            this.logger.error({ err, origin: 'gcs-logger' }, 'Failed to write logs to file');
+            this.logger.error({ err, origin: 'remote-logger' }, 'Failed to write logs to file');
         }
         finally {
             this.writePromise = undefined;
@@ -129,7 +129,7 @@ class GCSLoggerStream extends stream_1.Writable {
             return result;
         })
             .catch(err => {
-            this.logger.error({ err }, 'Failed to upload logs file to GCS');
+            this.logger.error({ err }, 'Failed to upload logs file');
         })
             .then(result => {
             this.uploadingPromise = undefined;
@@ -145,24 +145,10 @@ class GCSLoggerStream extends stream_1.Writable {
         const srcGeneratorAsync = async () => {
             return await this.createCompressedStream(fs_extra_1.default.createReadStream(this.temporaryLogsPath, { end: size }));
         };
-        if ('signedUrl' in this.uploadMethod) {
-            return await client_1.default.uploadWithSignedUrl({
-                signedUrl: this.uploadMethod.signedUrl,
-                srcGeneratorAsync,
-            });
-        }
-        const { Location } = await this.uploadMethod.client.uploadFile({
-            key: this.uploadMethod.key,
-            src: await srcGeneratorAsync(),
-            streamOptions: {
-                metadata: {
-                    contentType: 'text/plain;charset=utf-8',
-                    ...(this.compress !== null ? { contentEncoding: this.compress } : {}),
-                    customTime: this.uploadMethod.customTime,
-                },
-            },
+        return await (0, uploadWithSignedUrl_1.uploadWithSignedUrl)({
+            signedUrl: this.uploadMethod.signedUrl,
+            srcGeneratorAsync,
         });
-        return Location;
     }
     async createCompressedStream(src) {
         if (!this.compress) {
@@ -184,11 +170,11 @@ class GCSLoggerStream extends stream_1.Writable {
         return fs_extra_1.default.createReadStream(this.temporaryCompressedLogsPath, { end: size });
     }
 }
-(function (GCSLoggerStream) {
+(function (RemoteLoggerStream) {
     let CompressionMethod;
     (function (CompressionMethod) {
         CompressionMethod["GZIP"] = "gzip";
         CompressionMethod["BR"] = "br";
-    })(CompressionMethod = GCSLoggerStream.CompressionMethod || (GCSLoggerStream.CompressionMethod = {}));
-})(GCSLoggerStream || (GCSLoggerStream = {}));
-exports.default = GCSLoggerStream;
+    })(CompressionMethod = RemoteLoggerStream.CompressionMethod || (RemoteLoggerStream.CompressionMethod = {}));
+})(RemoteLoggerStream || (RemoteLoggerStream = {}));
+exports.default = RemoteLoggerStream;

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

@@ -17,6 +17,7 @@ export interface JUnitTestCaseResult {
     tags: string[];
     properties: Record<string, string>;
 }
+export declare function parseFailedFlowNamesFromJUnitFile(junitFile: string): Promise<Set<string>>;
 export declare function parseJUnitTestCases(junitDirectory: string): Promise<JUnitTestCaseResult[]>;
 export declare function isFileAttrRun(testcases: JUnitTestCaseResult[]): testcases is (JUnitTestCaseResult & {
     file: string;

package/dist/steps/functions/maestroResultParser.js

@@ -3,6 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseFailedFlowNamesFromJUnitFile = parseFailedFlowNamesFromJUnitFile;
 exports.parseJUnitTestCases = parseJUnitTestCases;
 exports.isFileAttrRun = isFileAttrRun;
 exports.junitFileHasFileAttrs = junitFileHasFileAttrs;
@@ -99,6 +100,17 @@ async function parseJUnitFile(filePath) {
         return [];
     }
 }
+// Raw names (slashes kept) of the testcases a single JUnit file marks failed. Best-effort: an
+// unreadable or malformed file yields an empty set rather than throwing.
+async function parseFailedFlowNamesFromJUnitFile(junitFile) {
+    const failed = new Set();
+    for (const testcase of await parseJUnitFile(junitFile)) {
+        if (testcase.status === 'failed') {
+            failed.add(testcase.name);
+        }
+    }
+    return failed;
+}
 async function parseJUnitTestCases(junitDirectory) {
     let entries;
     try {

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

@@ -18,6 +18,7 @@ export declare function harvestFailureScreenshotsAsync(args: {
     testsDirectory: string;
     capturedSinceMs: number;
     attemptIndex: number;
+    failedFlowNames: ReadonlySet<string>;
     logger: bunyan;
 }): Promise<HarvestedScreenshot[]>;
 export declare function computePureFailureFlowNames(testCases: readonly {