expo-release 2.3.2 → 2.4.0

package/dist/index.js

@@ -7,7 +7,7 @@ var trimmed = (schema) => z.preprocess((value) => typeof value === "string" ? va
 var trueFalse = (env, fallback) => trimmed(z.enum(["true", "false"])).default(fallback).transform((value) => value === "true").meta({ env: `EXPO_RELEASE_${env}` });
 var releaseFlags = z.object({
   profile: z.string().trim().min(1).meta({ env: "EXPO_RELEASE_PROFILE" }).describe("EAS build profile, also the default update channel"),
-  base: text("BASE").meta({ env: ["EXPO_RELEASE_BASE", "GITHUB_EVENT_BEFORE"] }).describe("Git base SHA for the impact diff"),
+  base: text("BASE").describe("Git base SHA for the impact diff (default: the merge base on a pull request, else github.event.before)"),
   head: text("HEAD").meta({ env: ["EXPO_RELEASE_HEAD", "GITHUB_SHA"] }).describe("Git head SHA for the impact diff"),
   platform: trimmed(z.enum(["ios", "android"])).default("ios").meta({ env: "EXPO_RELEASE_PLATFORM" }).describe("Native platform"),
   impactPaths: z.string().default(DEFAULT_IMPACT_PATHS.join(",")).transform((value, ctx) => {
@@ -28,8 +28,8 @@ var releaseFlags = z.object({
     "rollback-embedded"
   ])).default("deploy").meta({ env: "EXPO_RELEASE_OPERATION" }).describe("What to run"),
   deployType: trimmed(z.enum(["none", "ota", "native"])).default("none").meta({ env: "EXPO_RELEASE_DEPLOY_TYPE" }).describe("Decision type for operate"),
-  channel: text("CHANNEL").describe("EAS Update channel (default: the profile)"),
-  environment: text("ENVIRONMENT").describe("EAS environment for eas update (required for Expo SDK 55+)"),
+  channel: text("CHANNEL").describe("EAS Update channel (default: the eas.json profile channel, else the profile name)"),
+  environment: text("ENVIRONMENT").describe("EAS environment for eas update (required for Expo SDK 55+, where it defaults to the eas.json profile environment)"),
   autoSubmit: trueFalse("AUTO_SUBMIT", "true").describe("Pass --auto-submit on native builds"),
   preUpdate: text("PRE_UPDATE").describe("Shell command run before eas update"),
   postUpdate: text("POST_UPDATE").describe("Shell command run after a successful eas update"),
@@ -48,11 +48,13 @@ var releaseFlags = z.object({
       message: "required by --operation republish"
     });
 });
-function toReleaseOptions(command, { context: flags }) {
+function toReleaseOptions(command, { context: flags }, buildProfile = null) {
+  const environment = flags.environment ?? buildProfile?.environment;
   return {
     ...flags,
     command,
-    channel: flags.channel ?? flags.profile
+    channel: flags.channel ?? buildProfile?.channel ?? flags.profile,
+    ...environment ? { environment } : {}
   };
 }
 function needsDecide(operation) {
@@ -95,22 +97,119 @@ ${delimiter}`;
 }
 
 // src/run.ts
+import { existsSync } from "fs";
+import { dirname, join } from "path";
 function easCommand(...args) {
   const bin = process.env.EAS_BIN?.trim();
-  return [bin && bin.length > 0 ? bin : "eas", ...args];
+  return [bin && bin.length > 0 ? bin : localBin("eas") ?? "eas", ...args];
+}
+var localBins = new Map;
+function localBin(name) {
+  const cwd = process.cwd();
+  const cacheKey = `${cwd}\x00${name}`;
+  const cached = localBins.get(cacheKey);
+  if (cached !== undefined)
+    return cached;
+  let bin = null;
+  for (let dir = cwd;; dir = dirname(dir)) {
+    const candidate = join(dir, "node_modules", ".bin", name);
+    if (existsSync(candidate)) {
+      bin = candidate;
+      break;
+    }
+    if (existsSync(join(dir, ".git")) || dirname(dir) === dir)
+      break;
+  }
+  localBins.set(cacheKey, bin);
+  return bin;
 }
-async function runCaptured(command) {
-  const child = Bun.spawn(command, {
-    stdout: "pipe",
-    stderr: "pipe"
-  });
-  const [stdout, stderr, exitCode] = await Promise.all([
-    new Response(child.stdout).text(),
-    new Response(child.stderr).text(),
-    child.exited
+
+class CommandError extends Error {
+  tail;
+  constructor(message, tail) {
+    super(message);
+    this.tail = tail;
+    this.name = "CommandError";
+  }
+}
+var ERROR_TAIL_LINES = 20;
+function lastLines(output, count = ERROR_TAIL_LINES) {
+  return output.split(`
+`).map((line) => line.trimEnd()).filter((line) => line.trim().length > 0).slice(-count);
+}
+var DRAIN_AFTER_EXIT_MS = 1000;
+function collect(stream, echo, sink) {
+  const reader = stream.getReader();
+  const decoder = new TextDecoder;
+  let text = "";
+  const done = (async () => {
+    try {
+      for (;; ) {
+        const { value, done } = await reader.read();
+        if (done)
+          break;
+        echo?.write(value);
+        const part = decoder.decode(value, { stream: true });
+        text += part;
+        sink.push(part);
+      }
+    } catch {}
+    const rest = decoder.decode();
+    sink.push(rest);
+    text += rest;
+  })();
+  return {
+    done,
+    stop: () => reader.cancel().catch(() => {
+      return;
+    }),
+    text: () => text
+  };
+}
+async function spawn(command, echoStdout, echoStderr = true) {
+  const child = Bun.spawn(command, { stdout: "pipe", stderr: "pipe" });
+  const combined = [];
+  const out = collect(child.stdout, echoStdout ? process.stdout : null, combined);
+  const err = collect(child.stderr, echoStderr ? process.stderr : null, combined);
+  const exitCode = await child.exited;
+  const drained = Promise.all([out.done, err.done]);
+  let timer;
+  const timedOut = await Promise.race([
+    drained.then(() => false),
+    new Promise((resolve) => {
+      timer = setTimeout(() => resolve(true), DRAIN_AFTER_EXIT_MS);
+    })
   ]);
+  clearTimeout(timer);
+  if (timedOut) {
+    await Promise.all([out.stop(), err.stop()]);
+    await drained;
+  }
+  return {
+    stdout: out.text(),
+    stderr: err.text(),
+    exitCode,
+    tail: lastLines(combined.join(""))
+  };
+}
+async function runCaptured(command) {
+  const { stdout, stderr, exitCode, tail } = await spawn(command, false);
   if (exitCode !== 0) {
-    throw new Error(describeFailure(command, exitCode, { stderr, stdout }));
+    throw new CommandError(describeFailure(command, exitCode, { stderr, stdout }), tail);
+  }
+  return stdout;
+}
+async function runSilent(command) {
+  const { stdout, stderr, exitCode, tail } = await spawn(command, false, false);
+  if (exitCode !== 0) {
+    throw new CommandError(describeFailure(command, exitCode, { stderr, stdout }), tail);
+  }
+  return stdout;
+}
+async function runInherited(command) {
+  const { stdout, exitCode, tail } = await spawn(command, true);
+  if (exitCode !== 0) {
+    throw new CommandError(`Command failed with exit code ${exitCode}: ${quoteCommand(command)} (output above)`, tail);
   }
   return stdout;
 }
@@ -143,21 +242,28 @@ ${tail(output.stdout)}`);
   return sections.join(`
 `);
 }
-async function runInherited(command) {
-  const child = Bun.spawn(command, { stdout: "inherit", stderr: "inherit" });
-  const exitCode = await child.exited;
-  if (exitCode !== 0) {
-    throw new Error(`Command failed with exit code ${exitCode}: ${quoteCommand(command)} (output above)`);
+function parseJsonDocument(output) {
+  const starts = [0];
+  for (const match of output.matchAll(/\n(?=[[{])/g)) {
+    starts.push(match.index + 1);
+  }
+  for (const start of starts) {
+    try {
+      return {
+        value: JSON.parse(output.slice(start)),
+        preamble: output.slice(0, start).trim()
+      };
+    } catch {}
   }
-  return "";
+  throw new Error(`Expected JSON output, received:
+${tail(output)}`);
 }
 function parseJson(output) {
-  try {
-    return JSON.parse(output);
-  } catch {
-    throw new Error(`Expected JSON output, received:
-${output}`);
-  }
+  const { value, preamble } = parseJsonDocument(output);
+  if (preamble)
+    process.stderr.write(`${preamble}
+`);
+  return value;
 }
 function getRecord(value, context) {
   if (typeof value !== "object" || value === null || Array.isArray(value)) {
@@ -166,7 +272,7 @@ function getRecord(value, context) {
   return value;
 }
 function parseFingerprintHash(output) {
-  const record = getRecord(parseJson(output), "EAS fingerprint");
+  const record = getRecord(parseJsonDocument(output).value, "EAS fingerprint");
   if (typeof record.hash !== "string" || record.hash.length === 0) {
     throw new Error("EAS fingerprint output did not contain a full hash");
   }
@@ -179,8 +285,85 @@ function dryRunCommand(command) {
   process.stderr.write(`[dry-run] ${quoteCommand(command)}
 `);
 }
-async function generateFingerprint(input, commandRunner) {
-  return parseFingerprintHash(await commandRunner(easCommand("fingerprint:generate", "--platform", input.platform, "--build-profile", input.profile, "--json", "--non-interactive")));
+
+class StageError extends Error {
+  stage;
+  tail;
+  constructor(stage, message, tail = []) {
+    super(message);
+    this.stage = stage;
+    this.tail = tail;
+    this.name = "StageError";
+  }
+}
+async function stage(name, run) {
+  const started = performance.now();
+  try {
+    return await run();
+  } catch (error) {
+    if (error instanceof StageError)
+      throw error;
+    throw new StageError(name, error instanceof Error ? error.message : String(error), error instanceof CommandError ? error.tail : []);
+  } finally {
+    const seconds = ((performance.now() - started) / 1000).toFixed(1);
+    process.stderr.write(`[expo-release] ${name}: ${seconds}s
+`);
+  }
+}
+async function generateFingerprint(input, commandRunner, explainConfig) {
+  const output = await commandRunner(easCommand("fingerprint:generate", "--platform", input.platform, "--build-profile", input.profile, "--json", "--non-interactive"));
+  const { preamble } = parseJsonDocument(output);
+  if (preamble) {
+    const reason = explainConfig ? await explainConfig() : "";
+    throw new CommandError([
+      "eas fingerprint:generate could not load the app config and fell back to a default one, so its fingerprint may not match what EAS builds.",
+      `eas-cli printed:
+${preamble}`,
+      reason && `expo config said:
+${reason}`
+    ].filter(Boolean).join(`
+`), lastLines(reason || preamble));
+  }
+  return parseFingerprintHash(output);
+}
+
+// src/source-maps.ts
+import { exists } from "fs/promises";
+var SOURCE_MAP_OUTPUT_DIR = "dist";
+function expoCommand(...args) {
+  const bin = process.env.EXPO_BIN?.trim();
+  if (bin && bin.length > 0)
+    return [bin, ...args];
+  const local = localBin("expo");
+  return local ? [local, ...args] : ["bunx", "expo", ...args];
+}
+function sourceMapExportCommand(platform) {
+  return expoCommand("export", "--platform", platform, "--output-dir", SOURCE_MAP_OUTPUT_DIR, "--source-maps", "external");
+}
+function mergeUpdateArgs(extra, exportSourceMaps) {
+  const args = extra ? [...extra] : [];
+  if (!exportSourceMaps)
+    return args;
+  if (!args.includes("--input-dir")) {
+    args.push("--input-dir", SOURCE_MAP_OUTPUT_DIR);
+  }
+  if (!args.includes("--skip-bundler")) {
+    args.push("--skip-bundler");
+  }
+  return args;
+}
+async function defaultHasSourceMaps(directory = SOURCE_MAP_OUTPUT_DIR) {
+  if (!await exists(directory))
+    return false;
+  for await (const _ of new Bun.Glob("**/*.map").scan(directory)) {
+    return true;
+  }
+  return false;
+}
+async function assertSourceMaps(hasSourceMaps = defaultHasSourceMaps) {
+  if (await hasSourceMaps())
+    return;
+  throw new Error("Expo export did not produce Hermes source maps in dist; refusing to publish an OTA update.");
 }
 
 // src/decide.ts
@@ -219,8 +402,8 @@ function normalizeBuildStatus(value) {
   return null;
 }
 function dashboardBuildUrl(record) {
-  const ownerName = nestedString(record, "app", "ownerAccount", "name");
-  const slug = nestedString(record, "app", "slug");
+  const ownerName = nestedString(record, "project", "ownerAccount", "name") ?? nestedString(record, "app", "ownerAccount", "name");
+  const slug = nestedString(record, "project", "slug") ?? nestedString(record, "app", "slug");
   if (typeof record.id !== "string" || !ownerName || !slug) {
     return;
   }
@@ -245,13 +428,17 @@ function parseBuildList(output) {
     }
     const buildUrl = dashboardBuildUrl(record);
     const fingerprint = nestedString(record, "fingerprint", "hash");
-    const runtimeVersion = nestedString(record, "runtime", "version");
+    const runtimeVersion = nestedString(record, "runtimeVersion") ?? nestedString(record, "runtime", "version");
+    const errorCode = nestedString(record, "error", "errorCode");
+    const errorMessage = nestedString(record, "error", "message");
+    const error = [errorCode, errorMessage].filter(Boolean).join(": ");
     builds.push({
       id: record.id,
       status,
       ...buildUrl ? { buildUrl } : {},
       ...fingerprint ? { fingerprint } : {},
-      ...runtimeVersion ? { runtimeVersion } : {}
+      ...runtimeVersion ? { runtimeVersion } : {},
+      ...error ? { error } : {}
     });
   }
   return builds;
@@ -268,26 +455,71 @@ function hasExpoImpact(paths, impactPaths = DEFAULT_IMPACT_PATHS) {
 function resolveBuildDecision(builds) {
   const finished = builds.find((build) => build.status === "finished");
   if (finished) {
-    return { deployType: "ota", nativeBuildPending: false, build: finished };
+    return {
+      deployType: "ota",
+      reason: "finished-build",
+      nativeBuildPending: false,
+      build: finished
+    };
   }
   const inProgress = builds.find((build) => ACTIVE_BUILD_STATUSES.includes(build.status));
   if (inProgress) {
     return {
       deployType: "ota",
+      reason: "build-in-progress",
       nativeBuildPending: true,
       build: inProgress
     };
   }
   const newest = builds[0];
   if (newest?.status === "errored") {
-    const location = newest.buildUrl ?? newest.id;
-    throw new Error(`The most recent native build for this fingerprint failed (${location}). Fix the failure or use --operation force-native to queue another build.`);
+    const lines = [
+      `The newest native build for this fingerprint failed on EAS${newest.error ? `: ${newest.error}` : ` (build ${newest.id})`}`,
+      newest.buildUrl,
+      "Fix it, then run the workflow with operation force-native."
+    ].filter((line) => Boolean(line));
+    throw new StageError("errored build", lines.join(`
+`), lines);
   }
-  return { deployType: "native", nativeBuildPending: false, build: null };
+  return {
+    deployType: "native",
+    reason: "no-build-for-fingerprint",
+    nativeBuildPending: false,
+    build: null
+  };
+}
+async function readPullRequestBase() {
+  const path = process.env.GITHUB_EVENT_PATH;
+  if (!path)
+    return;
+  try {
+    const event = await Bun.file(path).json();
+    const sha = event.pull_request?.base?.sha;
+    return typeof sha === "string" && sha ? sha : undefined;
+  } catch {
+    return;
+  }
+}
+async function defaultBase(head, commandRunner) {
+  const event = process.env.GITHUB_EVENT_NAME;
+  if (event === "pull_request" || event === "pull_request_target") {
+    const base = await readPullRequestBase();
+    if (base && head) {
+      try {
+        const mergeBase = (await commandRunner(["git", "merge-base", base, head])).trim();
+        if (mergeBase)
+          return mergeBase;
+      } catch {}
+    }
+    if (base)
+      return base;
+  }
+  return process.env.GITHUB_EVENT_BEFORE?.trim() || undefined;
 }
 async function getChangedFiles(input, commandRunner) {
   const head = input.head;
-  if (!input.base || !head || /^0+$/.test(input.base)) {
+  const base = input.base ?? await defaultBase(head, commandRunner);
+  if (!base || !head || /^0+$/.test(base)) {
     return { files: [], unreachable: true };
   }
   try {
@@ -297,7 +529,7 @@ async function getChangedFiles(input, commandRunner) {
       "diff.relative=false",
       "diff",
       "--name-only",
-      input.base,
+      base,
       head
     ]);
     return {
@@ -312,25 +544,95 @@ async function getChangedFiles(input, commandRunner) {
 async function getMatchingBuilds(input, fingerprint, commandRunner) {
   return parseBuildList(await commandRunner(easCommand("build:list", "--platform", input.platform, "--build-profile", input.profile, "--fingerprint-hash", fingerprint, "--limit", "20", "--json", "--non-interactive")));
 }
+function fingerprintSources(value) {
+  const sources = value?.sources;
+  const map = new Map;
+  if (!Array.isArray(sources))
+    return map;
+  for (const source of sources) {
+    const key = source.type === "contents" ? source.id : source.filePath ?? source.id;
+    if (typeof key === "string")
+      map.set(key, source.hash ?? null);
+  }
+  return map;
+}
+var MAX_DIFF_SOURCES = 30;
+function diffFingerprintSources(compare) {
+  const record = getRecord(compare, "EAS fingerprint:compare");
+  const before = fingerprintSources(record.fingerprint1);
+  const after = fingerprintSources(record.fingerprint2);
+  const lines = [];
+  for (const [key, hash] of after) {
+    if (!before.has(key))
+      lines.push(`added ${key}`);
+    else if (before.get(key) !== hash)
+      lines.push(`changed ${key}`);
+  }
+  for (const key of before.keys()) {
+    if (!after.has(key))
+      lines.push(`removed ${key}`);
+  }
+  if (lines.length <= MAX_DIFF_SOURCES)
+    return lines;
+  return [
+    ...lines.slice(0, MAX_DIFF_SOURCES),
+    `... and ${lines.length - MAX_DIFF_SOURCES} more`
+  ];
+}
+async function explainNativeDecision(input, commandRunner) {
+  try {
+    return await stage("fingerprint diff", async () => {
+      const [last] = parseBuildList(await commandRunner(easCommand("build:list", "--platform", input.platform, "--build-profile", input.profile, "--status", "finished", "--limit", "1", "--json", "--non-interactive")));
+      if (!last)
+        return null;
+      const command = easCommand("fingerprint:compare", "--build-id", last.id, "--json", "--non-interactive");
+      if (input.environment)
+        command.push("--environment", input.environment);
+      const { value } = parseJsonDocument(await commandRunner(command));
+      return {
+        buildId: last.id,
+        ...last.buildUrl ? { buildUrl: last.buildUrl } : {},
+        sources: diffFingerprintSources(value)
+      };
+    });
+  } catch (error) {
+    process.stderr.write(`Warning: could not compare the fingerprint with the last finished build: ${error instanceof Error ? error.message : String(error)}
+`);
+    return null;
+  }
+}
+async function explainConfigFailure(commandRunner) {
+  try {
+    await commandRunner(expoCommand("config", "--json"));
+    return "";
+  } catch (error) {
+    return error instanceof Error ? error.message : String(error);
+  }
+}
 async function decideRelease(input, commandRunner = runCaptured) {
-  const { files: changedFiles, unreachable } = await getChangedFiles(input, commandRunner);
+  const { files: changedFiles, unreachable } = await stage("diff", () => getChangedFiles(input, commandRunner));
   if (!input.ignoreExpoImpact && !unreachable && !hasExpoImpact(changedFiles, input.impactPaths)) {
     return {
       deployType: "none",
+      reason: "no-impact-path",
       nativeBuildPending: false,
       changedFiles,
       fingerprint: null,
       build: null
     };
   }
-  const fingerprint = await generateFingerprint(input, commandRunner);
-  const resolved = resolveBuildDecision(await getMatchingBuilds(input, fingerprint, commandRunner));
+  await input.preflight?.();
+  const fingerprint = await stage("fingerprint", () => generateFingerprint(input, commandRunner, () => explainConfigFailure(commandRunner)));
+  const builds = await stage("build list", () => getMatchingBuilds(input, fingerprint, commandRunner));
+  const resolved = resolveBuildDecision(builds);
   return {
     deployType: resolved.deployType,
+    reason: resolved.reason,
     nativeBuildPending: resolved.nativeBuildPending,
     changedFiles,
     fingerprint,
-    build: resolved.build
+    build: resolved.build,
+    ...resolved.deployType === "native" ? { fingerprintDiff: await explainNativeDecision(input, commandRunner) } : {}
   };
 }
 async function writeDecideGitHubOutput(decision) {
@@ -340,51 +642,21 @@ async function writeDecideGitHubOutput(decision) {
     changed: String(decision.deployType !== "none"),
     fingerprint: decision.fingerprint ?? "",
     build_id: decision.build?.id ?? "",
-    build_url: decision.build?.buildUrl ?? ""
+    build_url: decision.build?.buildUrl ?? "",
+    reason: decision.reason,
+    changed_sources: decision.fingerprintDiff?.sources.join(`
+`) ?? "",
+    compared_build_url: decision.fingerprintDiff?.buildUrl ?? decision.fingerprintDiff?.buildId ?? ""
   });
 }
-// src/source-maps.ts
-import { exists } from "fs/promises";
-var SOURCE_MAP_OUTPUT_DIR = "dist";
-function expoCommand(...args) {
-  const bin = process.env.EXPO_BIN?.trim();
-  if (bin && bin.length > 0)
-    return [bin, ...args];
-  return ["bunx", "expo", ...args];
-}
-function sourceMapExportCommand(platform) {
-  return expoCommand("export", "--platform", platform, "--output-dir", SOURCE_MAP_OUTPUT_DIR, "--source-maps", "external");
-}
-function mergeUpdateArgs(extra, exportSourceMaps) {
-  const args = extra ? [...extra] : [];
-  if (!exportSourceMaps)
-    return args;
-  if (!args.includes("--input-dir")) {
-    args.push("--input-dir", SOURCE_MAP_OUTPUT_DIR);
-  }
-  if (!args.includes("--skip-bundler")) {
-    args.push("--skip-bundler");
+// src/operate.ts
+function splitArgs(value) {
+  const args = [];
+  for (const match of (value ?? "").matchAll(/"((?:\\.|[^"\\])*)"|'([^']*)'|(\S+)/g)) {
+    args.push(match[1]?.replace(/\\(.)/g, "$1") ?? match[2] ?? match[3] ?? "");
   }
   return args;
 }
-async function defaultHasSourceMaps(directory = SOURCE_MAP_OUTPUT_DIR) {
-  if (!await exists(directory))
-    return false;
-  for await (const _ of new Bun.Glob("**/*.map").scan(directory)) {
-    return true;
-  }
-  return false;
-}
-async function assertSourceMaps(hasSourceMaps = defaultHasSourceMaps) {
-  if (await hasSourceMaps())
-    return;
-  throw new Error("Expo export did not produce Hermes source maps in dist; refusing to publish an OTA update.");
-}
-
-// src/operate.ts
-function extraUpdateArgs(value) {
-  return value?.split(/\s+/).filter(Boolean) ?? [];
-}
 function updateMessage(input) {
   if (input.message)
     return input.message;
@@ -409,23 +681,25 @@ async function defaultReadPackageJson() {
     return null;
   return file.json();
 }
+async function readExpoSdkMajor(readPackageJson = defaultReadPackageJson) {
+  const pkg = await readPackageJson();
+  if (!pkg || typeof pkg !== "object")
+    return null;
+  const record = pkg;
+  return parseExpoSdkMajor(record.dependencies?.expo ?? record.devDependencies?.expo);
+}
 async function requireEnvironmentIfNeeded(input) {
   if (input.environment)
     return;
-  const pkg = await (input.readPackageJson ?? defaultReadPackageJson)();
-  if (!pkg || typeof pkg !== "object" || pkg === null)
-    return;
-  const record = pkg;
-  const version = record.dependencies?.expo ?? record.devDependencies?.expo;
-  const major = parseExpoSdkMajor(version);
+  const major = await readExpoSdkMajor(input.readPackageJson);
   if (major !== null && major >= 55) {
-    throw new Error("EAS Update requires --environment for Expo SDK 55+. Pass --environment <name>.");
+    throw new Error("EAS Update requires --environment for Expo SDK 55+. Pass --environment <name> or set build.<profile>.environment in eas.json.");
   }
 }
-async function runHook(command, commandRunner) {
+async function runHook(name, command, commandRunner) {
   if (!command)
     return;
-  await commandRunner(["bash", "-c", command]);
+  await stage(name, () => commandRunner(["bash", "-c", command]));
 }
 function mutatingRunner(commandRunner, dryRun) {
   return async (command) => {
@@ -439,33 +713,44 @@ function mutatingRunner(commandRunner, dryRun) {
 async function publishUpdate(input, commandRunner) {
   await requireEnvironmentIfNeeded(input);
   if (input.exportSourceMaps) {
-    await commandRunner(sourceMapExportCommand(input.platform));
-    if (input.dryRun !== true) {
-      await assertSourceMaps(input.hasSourceMaps);
-    }
+    await stage("ota export", async () => {
+      await commandRunner(sourceMapExportCommand(input.platform));
+      if (input.dryRun !== true) {
+        await assertSourceMaps(input.hasSourceMaps);
+      }
+    });
   }
-  await runHook(input.preUpdate, commandRunner);
+  await runHook("pre-update", input.preUpdate, commandRunner);
   const command = easCommand("update", "--channel", input.channel, "--platform", input.platform, "--message", updateMessage(input), "--non-interactive");
   if (input.environment) {
     command.push("--environment", input.environment);
   }
-  command.push(...mergeUpdateArgs(extraUpdateArgs(input.updateExtraArgs), input.exportSourceMaps === true));
-  await commandRunner(command);
-  await runHook(input.postUpdate, commandRunner);
+  command.push(...mergeUpdateArgs(splitArgs(input.updateExtraArgs), input.exportSourceMaps === true));
+  await stage("ota update", () => commandRunner(command));
+  await runHook("post-update", input.postUpdate, commandRunner);
 }
 async function queueNativeBuild(input, commandRunner) {
-  const command = easCommand("build", "--platform", input.platform, "--profile", input.profile, "--non-interactive", "--no-wait");
+  const command = easCommand("build", "--platform", input.platform, "--profile", input.profile, "--non-interactive", "--no-wait", "--json");
   if (input.autoSubmit) {
     command.push("--auto-submit");
   }
-  await commandRunner(command);
+  const output = await stage("native build", () => commandRunner(command));
+  try {
+    const queued = output.trim() ? parseBuildList(output)[0] : undefined;
+    if (queued)
+      input.onQueuedBuild?.(queued);
+  } catch (error) {
+    process.stderr.write(`Warning: could not read the queued build from eas build --json: ${error instanceof Error ? error.message : String(error)}
+`);
+  }
+  return "native-build";
 }
 async function resolveRuntimeVersion(input, commandRunner) {
   if (input.runtimeVersion)
     return input.runtimeVersion;
   if (input.fingerprint)
     return input.fingerprint;
-  return generateFingerprint(input, commandRunner);
+  return stage("fingerprint", () => generateFingerprint(input, commandRunner));
 }
 async function operateRelease(input, commandRunner = runInherited) {
   const execute = mutatingRunner(commandRunner, input.dryRun === true);
@@ -474,19 +759,19 @@ async function operateRelease(input, commandRunner = runInherited) {
       if (!input.group) {
         throw new Error("Usage: --operation republish requires --group <update-group-id>");
       }
+      const group = input.group;
       await requireEnvironmentIfNeeded(input);
-      await execute(easCommand("update:republish", "--group", input.group, "--platform", input.platform, "--message", updateMessage(input), "--non-interactive"));
+      await stage("recovery", () => execute(easCommand("update:republish", "--group", group, "--platform", input.platform, "--message", updateMessage(input), "--non-interactive")));
       return "recovery";
     }
     case "rollback-embedded": {
       await requireEnvironmentIfNeeded(input);
       const runtimeVersion = await resolveRuntimeVersion(input, commandRunner);
-      await execute(easCommand("update:roll-back-to-embedded", "--channel", input.channel, "--platform", input.platform, "--runtime-version", runtimeVersion, "--message", updateMessage(input), "--non-interactive"));
+      await stage("recovery", () => execute(easCommand("update:roll-back-to-embedded", "--channel", input.channel, "--platform", input.platform, "--runtime-version", runtimeVersion, "--message", updateMessage(input), "--non-interactive")));
       return "recovery";
     }
     case "force-native":
-      await queueNativeBuild(input, execute);
-      return "native-build";
+      return queueNativeBuild(input, execute);
     case "retry-ota":
       await publishUpdate(input, execute);
       return "ota";
@@ -501,8 +786,7 @@ async function operateRelease(input, commandRunner = runInherited) {
     case "none":
       return "skipped";
     case "native":
-      await queueNativeBuild(input, execute);
-      return "native-build";
+      return queueNativeBuild(input, execute);
     case "ota":
       await publishUpdate(input, execute);
       return "ota";
@@ -512,8 +796,12 @@ async function operateRelease(input, commandRunner = runInherited) {
     }
   }
 }
-async function writeOperateGitHubOutput(result) {
-  await appendGitHubOutput({ result });
+async function writeOperateGitHubOutput(result, queuedBuild) {
+  await appendGitHubOutput({
+    result,
+    queued_build_id: queuedBuild?.id ?? "",
+    queued_build_url: queuedBuild?.buildUrl ?? ""
+  });
 }
 export {
   DEFAULT_IMPACT_PATHS,