expo-release 2.0.0 → 2.2.1

package/dist/cli.js

@@ -1,62 +1,65 @@
 #!/usr/bin/env bun
 // @bun
 
+// src/cli.ts
+import { defineCli, defineCommand } from "hanzio/cli";
+
 // src/args.ts
-import { parseArgs } from "util";
+import { z } from "zod";
 var DEFAULT_IMPACT_PATHS = ["apps/expo/"];
-var USAGE = "Usage: expo-release <release|decide|operate> --profile <profile> [--base <sha>] [--head <sha>] [--platform ios|android] [--impact-paths apps/expo/] [--operation deploy|force-native|retry-ota|republish|rollback-embedded] [--deploy-type none|ota|native] [--channel <channel>] [--environment <env>] [--group <id>] [--runtime-version <hash>] [--message <msg>] [--fingerprint <hash>] [--auto-submit true] [--pre-update <cmd>] [--post-update <cmd>] [--update-extra-args <args>] [--dry-run] [--ignore-expo-impact true]";
-function fromEnv(env, name) {
-  const value = env[name]?.trim();
-  return value ? value : undefined;
-}
-function firstDefined(...values) {
-  return values.find((value) => value !== undefined && value.length > 0);
-}
-function optionalString(value) {
-  const trimmed = value?.trim();
-  return trimmed ? trimmed : undefined;
-}
-function parseImpactPaths(value) {
-  const paths = (value ?? DEFAULT_IMPACT_PATHS.join(",")).split(",").map((path) => path.trim()).filter(Boolean);
-  if (paths.length === 0) {
-    throw new Error("At least one --impact-paths entry is required");
-  }
-  return paths;
-}
-function parsePlatform(value) {
-  if (value === undefined || value === "ios")
-    return "ios";
-  if (value === "android")
-    return "android";
-  throw new Error("Usage: --platform ios|android");
-}
-function parseBoolean(value, fallback) {
-  if (value === undefined)
-    return fallback;
-  if (value === "true")
-    return true;
-  if (value === "false")
-    return false;
-  throw new Error(`Expected true or false, received: ${value}`);
-}
-function parseOperation(value) {
-  if (value === undefined || value === "deploy" || value === "force-native" || value === "retry-ota" || value === "republish" || value === "rollback-embedded") {
-    return value ?? "deploy";
-  }
-  throw new Error("Usage: --operation deploy|force-native|retry-ota|republish|rollback-embedded");
-}
-function parseDeployType(value) {
-  if (value === undefined || value === "none")
-    return "none";
-  if (value === "ota" || value === "native")
-    return value;
-  throw new Error("Usage: --deploy-type none|ota|native");
-}
-function parseCommandName(value) {
-  if (value === "release" || value === "decide" || value === "operate") {
-    return value;
-  }
-  throw new Error(USAGE);
+var text = (env) => z.string().transform((value) => value.trim() || undefined).optional().meta({ env: `EXPO_RELEASE_${env}` });
+var trueFalse = (env, fallback) => 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").describe("Git base SHA for the impact diff (falls back to GITHUB_EVENT_BEFORE)"),
+  head: text("HEAD").describe("Git head SHA for the impact diff (falls back to GITHUB_SHA)"),
+  platform: 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) => {
+    const paths = value.split(",").map((path) => path.trim()).filter(Boolean);
+    if (paths.length === 0)
+      ctx.addIssue({
+        code: "custom",
+        message: "At least one --impact-paths entry is required"
+      });
+    return paths;
+  }).meta({ env: "EXPO_RELEASE_IMPACT_PATHS" }).describe("Comma-separated repo-root paths that count as an Expo change"),
+  ignoreExpoImpact: trueFalse("IGNORE_EXPO_IMPACT", "false").describe("Check the fingerprint even when no impact path changed"),
+  operation: z.enum([
+    "deploy",
+    "force-native",
+    "retry-ota",
+    "republish",
+    "rollback-embedded"
+  ]).default("deploy").meta({ env: "EXPO_RELEASE_OPERATION" }).describe("What to run"),
+  deployType: 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+)"),
+  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"),
+  updateExtraArgs: text("UPDATE_EXTRA_ARGS").describe("Extra tokens appended to eas update"),
+  exportSourceMaps: trueFalse("EXPORT_SOURCE_MAPS", "false").describe("On OTA, expo export with external source maps, then publish dist"),
+  group: text("GROUP").describe("Update group ID for --operation republish"),
+  runtimeVersion: text("RUNTIME_VERSION").describe("Runtime version for rollback-embedded (default: the fingerprint)"),
+  message: text("MESSAGE").describe("Override the eas update message"),
+  fingerprint: text("FINGERPRINT").describe("Fingerprint hash to use instead of generating one"),
+  dryRun: z.boolean().meta({ env: "EXPO_RELEASE_DRY_RUN" }).describe("Print mutating EAS commands without running them")
+}).superRefine((flags, ctx) => {
+  if (flags.operation === "republish" && !flags.group)
+    ctx.addIssue({
+      code: "custom",
+      path: ["group"],
+      message: "required by --operation republish"
+    });
+});
+function toReleaseOptions(command, { context: flags, env }) {
+  return {
+    ...flags,
+    command,
+    base: flags.base ?? env.GITHUB_EVENT_BEFORE,
+    head: flags.head ?? env.GITHUB_SHA,
+    channel: flags.channel ?? flags.profile
+  };
 }
 function needsDecide(operation) {
   switch (operation) {
@@ -80,80 +83,6 @@ function shouldIgnoreExpoImpact(options) {
     return true;
   return process.env.GITHUB_EVENT_NAME === "workflow_dispatch" && options.operation === "deploy";
 }
-function parseReleaseOptions(args, env = process.env) {
-  let values;
-  let positionals;
-  try {
-    const parsed = parseArgs({
-      args,
-      allowPositionals: true,
-      strict: true,
-      options: {
-        profile: { type: "string" },
-        base: { type: "string" },
-        head: { type: "string" },
-        platform: { type: "string" },
-        "impact-paths": { type: "string" },
-        "ignore-expo-impact": { type: "string" },
-        operation: { type: "string" },
-        "deploy-type": { type: "string" },
-        channel: { type: "string" },
-        environment: { type: "string" },
-        "auto-submit": { type: "string" },
-        "pre-update": { type: "string" },
-        "post-update": { type: "string" },
-        "update-extra-args": { type: "string" },
-        group: { type: "string" },
-        "runtime-version": { type: "string" },
-        message: { type: "string" },
-        fingerprint: { type: "string" },
-        "dry-run": { type: "boolean", default: false }
-      }
-    });
-    values = parsed.values;
-    positionals = parsed.positionals;
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    throw new Error(`${USAGE}
-${message}`);
-  }
-  if (positionals.length > 1) {
-    throw new Error(USAGE);
-  }
-  const command = parseCommandName(positionals[0] ?? fromEnv(env, "EXPO_RELEASE_COMMAND"));
-  const profile = firstDefined(values.profile, fromEnv(env, "EXPO_RELEASE_PROFILE"));
-  if (!profile) {
-    throw new Error(USAGE);
-  }
-  const operation = parseOperation(firstDefined(values.operation, fromEnv(env, "EXPO_RELEASE_OPERATION")));
-  const group = optionalString(firstDefined(values.group, fromEnv(env, "EXPO_RELEASE_GROUP")));
-  if (operation === "republish" && !group) {
-    throw new Error("Usage: --operation republish requires --group <update-group-id>");
-  }
-  const channel = firstDefined(values.channel, fromEnv(env, "EXPO_RELEASE_CHANNEL")) ?? profile;
-  return {
-    command,
-    profile,
-    base: optionalString(firstDefined(values.base, fromEnv(env, "EXPO_RELEASE_BASE"), fromEnv(env, "GITHUB_EVENT_BEFORE"))),
-    head: optionalString(firstDefined(values.head, fromEnv(env, "EXPO_RELEASE_HEAD"), fromEnv(env, "GITHUB_SHA"))),
-    platform: parsePlatform(firstDefined(values.platform, fromEnv(env, "EXPO_RELEASE_PLATFORM"))),
-    impactPaths: parseImpactPaths(firstDefined(values["impact-paths"], fromEnv(env, "EXPO_RELEASE_IMPACT_PATHS"))),
-    ignoreExpoImpact: parseBoolean(firstDefined(values["ignore-expo-impact"], fromEnv(env, "EXPO_RELEASE_IGNORE_EXPO_IMPACT")), false),
-    operation,
-    deployType: parseDeployType(firstDefined(values["deploy-type"], fromEnv(env, "EXPO_RELEASE_DEPLOY_TYPE"))),
-    channel,
-    environment: optionalString(firstDefined(values.environment, fromEnv(env, "EXPO_RELEASE_ENVIRONMENT"))),
-    autoSubmit: parseBoolean(firstDefined(values["auto-submit"], fromEnv(env, "EXPO_RELEASE_AUTO_SUBMIT")), true),
-    preUpdate: optionalString(firstDefined(values["pre-update"], fromEnv(env, "EXPO_RELEASE_PRE_UPDATE"))),
-    postUpdate: optionalString(firstDefined(values["post-update"], fromEnv(env, "EXPO_RELEASE_POST_UPDATE"))),
-    updateExtraArgs: optionalString(firstDefined(values["update-extra-args"], fromEnv(env, "EXPO_RELEASE_UPDATE_EXTRA_ARGS"))),
-    group,
-    runtimeVersion: optionalString(firstDefined(values["runtime-version"], fromEnv(env, "EXPO_RELEASE_RUNTIME_VERSION"))),
-    message: optionalString(firstDefined(values.message, fromEnv(env, "EXPO_RELEASE_MESSAGE"))),
-    fingerprint: optionalString(firstDefined(values.fingerprint, fromEnv(env, "EXPO_RELEASE_FINGERPRINT"))),
-    dryRun: values["dry-run"] === true || parseBoolean(fromEnv(env, "EXPO_RELEASE_DRY_RUN"), false)
-  };
-}
 
 // src/github-output.ts
 import { appendFile } from "fs/promises";
@@ -188,16 +117,44 @@ async function runCaptured(command) {
     child.exited
   ]);
   if (exitCode !== 0) {
-    throw new Error(`Command failed (${command.join(" ")}):
-${stderr || stdout}`);
+    throw new Error(describeFailure(command, exitCode, { stderr, stdout }));
   }
   return stdout;
 }
+var OUTPUT_TAIL_LINES = 100;
+function tail(output) {
+  const lines = output.trimEnd().split(`
+`);
+  if (lines.length <= OUTPUT_TAIL_LINES)
+    return lines.join(`
+`);
+  const omitted = lines.length - OUTPUT_TAIL_LINES;
+  return [
+    `... (${omitted} earlier lines omitted)`,
+    ...lines.slice(-OUTPUT_TAIL_LINES)
+  ].join(`
+`);
+}
+function describeFailure(command, exitCode, output) {
+  const sections = [
+    `Command failed with exit code ${exitCode}: ${quoteCommand(command)}`
+  ];
+  if (output.stderr.trim())
+    sections.push(`stderr:
+${tail(output.stderr)}`);
+  if (output.stdout.trim())
+    sections.push(`stdout:
+${tail(output.stdout)}`);
+  if (sections.length === 1)
+    sections.push("(no output)");
+  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 (${command.join(" ")})`);
+    throw new Error(`Command failed with exit code ${exitCode}: ${quoteCommand(command)} (output above)`);
   }
   return "";
 }
@@ -394,6 +351,44 @@ async function writeDecideGitHubOutput(decision) {
   });
 }
 
+// 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");
+  }
+  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) ?? [];
@@ -451,12 +446,18 @@ 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 runHook(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(...extraUpdateArgs(input.updateExtraArgs));
+  command.push(...mergeUpdateArgs(extraUpdateArgs(input.updateExtraArgs), input.exportSourceMaps === true));
   await commandRunner(command);
   await runHook(input.postUpdate, commandRunner);
 }
@@ -550,50 +551,56 @@ function toOperationInput(options, decision) {
     preUpdate: options.preUpdate,
     postUpdate: options.postUpdate,
     updateExtraArgs: options.updateExtraArgs,
+    exportSourceMaps: options.exportSourceMaps,
     dryRun: options.dryRun
   };
 }
-async function main() {
-  const raw = Bun.argv.slice(2);
-  if (raw.length === 0 || raw[0] === "--help" || raw[0] === "-h") {
-    process.stdout.write(`${USAGE}
+async function decide(options, ctx) {
+  const decision = await decideRelease(toDecisionInput(options));
+  await writeDecideGitHubOutput(decision);
+  ctx.stdout.write(`${JSON.stringify(decision)}
 `);
-    return;
-  }
-  const options = parseReleaseOptions(raw);
-  switch (options.command) {
-    case "decide": {
-      const decision = await decideRelease(toDecisionInput(options));
-      await writeDecideGitHubOutput(decision);
-      process.stdout.write(`${JSON.stringify(decision)}
-`);
-      return;
-    }
-    case "operate": {
-      const result = await operateRelease(toOperationInput(options, null));
-      await writeOperateGitHubOutput(result);
-      process.stdout.write(`${result}
-`);
-      return;
-    }
-    case "release": {
-      let decision = null;
-      if (needsDecide(options.operation)) {
-        decision = await decideRelease(toDecisionInput(options));
-        await writeDecideGitHubOutput(decision);
-        process.stdout.write(`${JSON.stringify(decision)}
+  return decision;
+}
+async function operate(options, decision, ctx) {
+  const result = await operateRelease(toOperationInput(options, decision));
+  await writeOperateGitHubOutput(result);
+  ctx.stdout.write(`${result}
 `);
+}
+var COMMANDS = ["release", "decide", "operate"];
+var cli = defineCli({
+  name: "expo-release",
+  description: "Fingerprint-driven Expo EAS release: OTA update or native store build",
+  globals: releaseFlags,
+  context: (flags) => flags,
+  commands: {
+    release: defineCommand({
+      description: "Run decide, then operate on its decision",
+      run: async (_input, ctx) => {
+        const options = toReleaseOptions("release", ctx);
+        const decision = needsDecide(options.operation) ? await decide(options, ctx) : null;
+        await operate(options, decision, ctx);
       }
-      const result = await operateRelease(toOperationInput(options, decision));
-      await writeOperateGitHubOutput(result);
-      process.stdout.write(`${result}
-`);
-      return;
-    }
-    default: {
-      const _exhaustive = options.command;
-      throw new Error(`Unsupported command: ${_exhaustive}`);
-    }
+    }),
+    decide: defineCommand({
+      description: "Print whether this change needs no deploy, an OTA update or a native build",
+      run: async (_input, ctx) => {
+        await decide(toReleaseOptions("decide", ctx), ctx);
+      }
+    }),
+    operate: defineCommand({
+      description: "Run --operation for --deploy-type",
+      run: async (_input, ctx) => {
+        await operate(toReleaseOptions("operate", ctx), null, ctx);
+      }
+    })
   }
+});
+var env = Object.fromEntries(Object.entries(process.env).flatMap(([name, value]) => value?.trim() ? [[name, value.trim()]] : []));
+var argv = process.argv.slice(2);
+if (!argv.some((arg) => COMMANDS.includes(arg))) {
+  argv = env.EXPO_RELEASE_COMMAND ? [env.EXPO_RELEASE_COMMAND, ...argv] : argv.length === 0 ? ["--help"] : argv;
 }
-await main();
+var code = await cli.run(argv, { env });
+process.exitCode = code === 2 ? 1 : code;