expo-release 2.0.0

package/dist/index.js

@@ -0,0 +1,525 @@
+// @bun
+// src/args.ts
+import { parseArgs } from "util";
+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);
+}
+function needsDecide(operation) {
+  switch (operation) {
+    case "deploy":
+    case "retry-ota":
+      return true;
+    case "force-native":
+    case "republish":
+    case "rollback-embedded":
+      return false;
+    default: {
+      const _exhaustive = operation;
+      throw new Error(`Unsupported operation: ${_exhaustive}`);
+    }
+  }
+}
+function shouldIgnoreExpoImpact(options) {
+  if (options.ignoreExpoImpact)
+    return true;
+  if (options.operation === "retry-ota")
+    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";
+async function appendGitHubOutput(entries) {
+  const outputPath = process.env.GITHUB_OUTPUT;
+  if (!outputPath)
+    return;
+  const lines = Object.entries(entries).map(([key, value]) => {
+    const delimiter = `EOF_${key}_${crypto.randomUUID().replaceAll("-", "")}`;
+    return `${key}<<${delimiter}
+${value}
+${delimiter}`;
+  });
+  await appendFile(outputPath, `${lines.join(`
+`)}
+`);
+}
+
+// src/run.ts
+function easCommand(...args) {
+  const bin = process.env.EAS_BIN?.trim();
+  return [bin && bin.length > 0 ? bin : "eas", ...args];
+}
+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
+  ]);
+  if (exitCode !== 0) {
+    throw new Error(`Command failed (${command.join(" ")}):
+${stderr || stdout}`);
+  }
+  return stdout;
+}
+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(" ")})`);
+  }
+  return "";
+}
+function parseJson(output) {
+  try {
+    return JSON.parse(output);
+  } catch {
+    throw new Error(`Expected JSON output, received:
+${output}`);
+  }
+}
+function getRecord(value, context) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new Error(`${context} must be an object`);
+  }
+  return value;
+}
+function parseFingerprintHash(output) {
+  const record = getRecord(parseJson(output), "EAS fingerprint");
+  if (typeof record.hash !== "string" || record.hash.length === 0) {
+    throw new Error("EAS fingerprint output did not contain a full hash");
+  }
+  return record.hash;
+}
+function quoteCommand(command) {
+  return command.map((part) => /[\s"]/.test(part) ? `"${part.replaceAll('"', "\\\"")}"` : part).join(" ");
+}
+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")));
+}
+
+// src/decide.ts
+var ACTIVE_BUILD_STATUSES = [
+  "in-progress",
+  "new",
+  "in-queue",
+  "pending-cancel"
+];
+var KNOWN_BUILD_STATUSES = new Set([
+  "finished",
+  "in-progress",
+  "new",
+  "in-queue",
+  "pending-cancel",
+  "errored",
+  "canceled"
+]);
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function nestedString(record, ...path) {
+  let current = record;
+  for (const key of path) {
+    if (!isRecord(current))
+      return;
+    current = current[key];
+  }
+  return typeof current === "string" && current.length > 0 ? current : undefined;
+}
+function normalizeBuildStatus(value) {
+  const status = value.toLowerCase().replaceAll("_", "-");
+  if (KNOWN_BUILD_STATUSES.has(status)) {
+    return status;
+  }
+  return null;
+}
+function dashboardBuildUrl(record) {
+  const ownerName = nestedString(record, "app", "ownerAccount", "name");
+  const slug = nestedString(record, "app", "slug");
+  if (typeof record.id !== "string" || !ownerName || !slug) {
+    return;
+  }
+  return `https://expo.dev/accounts/${ownerName}/projects/${slug}/builds/${record.id}`;
+}
+function parseBuildList(output) {
+  const parsed = parseJson(output);
+  if (!Array.isArray(parsed)) {
+    throw new Error("EAS build:list did not return an array");
+  }
+  const builds = [];
+  for (const value of parsed) {
+    const record = getRecord(value, "EAS build");
+    if (typeof record.id !== "string" || typeof record.status !== "string") {
+      throw new Error("EAS build must include string id and status fields");
+    }
+    const status = normalizeBuildStatus(record.status);
+    if (!status) {
+      process.stderr.write(`Warning: ignoring EAS build ${record.id} with unsupported status ${record.status}
+`);
+      continue;
+    }
+    const buildUrl = dashboardBuildUrl(record);
+    const fingerprint = nestedString(record, "fingerprint", "hash");
+    const runtimeVersion = nestedString(record, "runtime", "version");
+    builds.push({
+      id: record.id,
+      status,
+      ...buildUrl ? { buildUrl } : {},
+      ...fingerprint ? { fingerprint } : {},
+      ...runtimeVersion ? { runtimeVersion } : {}
+    });
+  }
+  return builds;
+}
+function isExpoImpactPath(path, impactPaths = DEFAULT_IMPACT_PATHS) {
+  return impactPaths.some((impactPath) => {
+    const prefix = impactPath.endsWith("/") ? impactPath.slice(0, -1) : impactPath;
+    return path === prefix || path === impactPath || path.startsWith(`${prefix}/`);
+  });
+}
+function hasExpoImpact(paths, impactPaths = DEFAULT_IMPACT_PATHS) {
+  return paths.some((path) => isExpoImpactPath(path, impactPaths));
+}
+function resolveBuildDecision(builds) {
+  const finished = builds.find((build) => build.status === "finished");
+  if (finished) {
+    return { deployType: "ota", nativeBuildPending: false, build: finished };
+  }
+  const inProgress = builds.find((build) => ACTIVE_BUILD_STATUSES.includes(build.status));
+  if (inProgress) {
+    return {
+      deployType: "ota",
+      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.`);
+  }
+  return { deployType: "native", nativeBuildPending: false, build: null };
+}
+async function getChangedFiles(input, commandRunner) {
+  const head = input.head;
+  if (!input.base || !head || /^0+$/.test(input.base)) {
+    return { files: [], unreachable: true };
+  }
+  try {
+    const output = await commandRunner([
+      "git",
+      "-c",
+      "diff.relative=false",
+      "diff",
+      "--name-only",
+      input.base,
+      head
+    ]);
+    return {
+      files: output.split(`
+`).map((path) => path.trim()).filter(Boolean),
+      unreachable: false
+    };
+  } catch {
+    return { files: [], unreachable: true };
+  }
+}
+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")));
+}
+async function decideRelease(input, commandRunner = runCaptured) {
+  const { files: changedFiles, unreachable } = await getChangedFiles(input, commandRunner);
+  if (!input.ignoreExpoImpact && !unreachable && !hasExpoImpact(changedFiles, input.impactPaths)) {
+    return {
+      deployType: "none",
+      nativeBuildPending: false,
+      changedFiles,
+      fingerprint: null,
+      build: null
+    };
+  }
+  const fingerprint = await generateFingerprint(input, commandRunner);
+  const resolved = resolveBuildDecision(await getMatchingBuilds(input, fingerprint, commandRunner));
+  return {
+    deployType: resolved.deployType,
+    nativeBuildPending: resolved.nativeBuildPending,
+    changedFiles,
+    fingerprint,
+    build: resolved.build
+  };
+}
+async function writeDecideGitHubOutput(decision) {
+  await appendGitHubOutput({
+    deploy_type: decision.deployType,
+    native_build_pending: String(decision.nativeBuildPending),
+    changed: String(decision.deployType !== "none"),
+    fingerprint: decision.fingerprint ?? "",
+    build_id: decision.build?.id ?? "",
+    build_url: decision.build?.buildUrl ?? ""
+  });
+}
+// src/operate.ts
+function extraUpdateArgs(value) {
+  return value?.split(/\s+/).filter(Boolean) ?? [];
+}
+function updateMessage(input) {
+  if (input.message)
+    return input.message;
+  const sha = process.env.GITHUB_SHA?.slice(0, 7) ?? "manual";
+  const fingerprint = input.fingerprint?.slice(0, 8);
+  if (fingerprint) {
+    return `${input.profile} ${sha} (fp ${fingerprint})`;
+  }
+  return `${input.profile} ${sha}`;
+}
+function parseExpoSdkMajor(version) {
+  if (!version)
+    return null;
+  const match = version.match(/(\d+)/);
+  if (!match?.[1])
+    return null;
+  return Number(match[1]);
+}
+async function defaultReadPackageJson() {
+  const file = Bun.file("package.json");
+  if (!await file.exists())
+    return null;
+  return file.json();
+}
+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);
+  if (major !== null && major >= 55) {
+    throw new Error("EAS Update requires --environment for Expo SDK 55+. Pass --environment <name>.");
+  }
+}
+async function runHook(command, commandRunner) {
+  if (!command)
+    return;
+  await commandRunner(["bash", "-c", command]);
+}
+function mutatingRunner(commandRunner, dryRun) {
+  return async (command) => {
+    if (dryRun) {
+      dryRunCommand(command);
+      return "";
+    }
+    return commandRunner(command);
+  };
+}
+async function publishUpdate(input, commandRunner) {
+  await requireEnvironmentIfNeeded(input);
+  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));
+  await commandRunner(command);
+  await runHook(input.postUpdate, commandRunner);
+}
+async function queueNativeBuild(input, commandRunner) {
+  const command = easCommand("build", "--platform", input.platform, "--profile", input.profile, "--non-interactive", "--no-wait");
+  if (input.autoSubmit) {
+    command.push("--auto-submit");
+  }
+  await commandRunner(command);
+}
+async function resolveRuntimeVersion(input, commandRunner) {
+  if (input.runtimeVersion)
+    return input.runtimeVersion;
+  if (input.fingerprint)
+    return input.fingerprint;
+  return generateFingerprint(input, commandRunner);
+}
+async function operateRelease(input, commandRunner = runInherited) {
+  const execute = mutatingRunner(commandRunner, input.dryRun === true);
+  switch (input.operation) {
+    case "republish": {
+      if (!input.group) {
+        throw new Error("Usage: --operation republish requires --group <update-group-id>");
+      }
+      await requireEnvironmentIfNeeded(input);
+      await execute(easCommand("update:republish", "--group", input.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"));
+      return "recovery";
+    }
+    case "force-native":
+      await queueNativeBuild(input, execute);
+      return "native-build";
+    case "retry-ota":
+      await publishUpdate(input, execute);
+      return "ota";
+    case "deploy":
+      break;
+    default: {
+      const _exhaustive = input.operation;
+      throw new Error(`Unsupported operation: ${_exhaustive}`);
+    }
+  }
+  switch (input.deployType) {
+    case "none":
+      return "skipped";
+    case "native":
+      await queueNativeBuild(input, execute);
+      return "native-build";
+    case "ota":
+      await publishUpdate(input, execute);
+      return "ota";
+    default: {
+      const _exhaustive = input.deployType;
+      throw new Error(`Unsupported deploy type: ${_exhaustive}`);
+    }
+  }
+}
+async function writeOperateGitHubOutput(result) {
+  await appendGitHubOutput({ result });
+}
+export {
+  operateRelease,
+  decideRelease,
+  DEFAULT_IMPACT_PATHS
+};

package/dist/operate.d.ts

@@ -0,0 +1,31 @@
+import type { DeployType, Operation, ReleasePlatform } from './args';
+import { type CommandRunner } from './run';
+export type { Operation };
+export type OperationInput = {
+    profile: string;
+    deployType: DeployType;
+    operation: Operation;
+    channel: string;
+    environment?: string;
+    platform: ReleasePlatform;
+    autoSubmit: boolean;
+    fingerprint?: string;
+    group?: string;
+    runtimeVersion?: string;
+    message?: string;
+    preUpdate?: string;
+    postUpdate?: string;
+    updateExtraArgs?: string;
+    dryRun?: boolean;
+    readPackageJson?: () => Promise<unknown>;
+};
+export type OperationResult = 'skipped' | 'ota' | 'native-build' | 'recovery';
+export declare function updateMessage(input: {
+    profile: string;
+    fingerprint?: string;
+    message?: string;
+}): string;
+export declare function parseExpoSdkMajor(version: string | undefined): number | null;
+export declare function requireEnvironmentIfNeeded(input: Pick<OperationInput, 'environment' | 'readPackageJson'>): Promise<void>;
+export declare function operateRelease(input: OperationInput, commandRunner?: CommandRunner): Promise<OperationResult>;
+export declare function writeOperateGitHubOutput(result: OperationResult): Promise<void>;

package/dist/run.d.ts

@@ -0,0 +1,13 @@
+export type CommandRunner = (command: string[]) => Promise<string>;
+export declare function easCommand(...args: string[]): string[];
+export declare function runCaptured(command: string[]): Promise<string>;
+export declare function runInherited(command: string[]): Promise<string>;
+export declare function parseJson(output: string): unknown;
+export declare function getRecord(value: unknown, context: string): Record<string, unknown>;
+export declare function parseFingerprintHash(output: string): string;
+export declare function quoteCommand(command: string[]): string;
+export declare function dryRunCommand(command: string[]): void;
+export declare function generateFingerprint(input: {
+    platform: string;
+    profile: string;
+}, commandRunner: CommandRunner): Promise<string>;

package/package.json

@@ -0,0 +1,63 @@
+{
+	"name": "expo-release",
+	"version": "2.0.0",
+	"description": "Fingerprint-driven Expo EAS release: OTA update or native store build",
+	"type": "module",
+	"module": "./dist/index.js",
+	"main": "./dist/index.js",
+	"types": "./dist/index.d.ts",
+	"license": "MIT",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/HansKristoffer/expo-release.git"
+	},
+	"author": "Kristoffer Hansen",
+	"keywords": [
+		"expo",
+		"eas",
+		"eas-update",
+		"fingerprint",
+		"ota",
+		"testflight",
+		"github-actions"
+	],
+	"engines": {
+		"bun": ">=1.0.0"
+	},
+	"files": [
+		"src/**/*.ts",
+		"dist",
+		"action.yml",
+		"!src/**/*.test.ts"
+	],
+	"bin": {
+		"expo-release": "./dist/cli.js"
+	},
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"bun": "./src/index.ts",
+			"import": "./dist/index.js",
+			"default": "./dist/index.js"
+		}
+	},
+	"scripts": {
+		"build": "bun run build:js && bun run build:types",
+		"build:js": "bun build ./src/index.ts ./src/cli.ts --outdir ./dist --target bun --packages external",
+		"build:types": "tsgo -p tsconfig.build.json",
+		"prepublishOnly": "bun run build",
+		"publish:patch": "npm version patch && npm publish",
+		"publish:minor": "npm version minor && npm publish",
+		"publish:major": "npm version major && npm publish",
+		"test": "bun test",
+		"lint": "bun run typecheck && bun biome check",
+		"lint:write": "bun run typecheck && bun biome check --write",
+		"typecheck": "tsgo --noEmit"
+	},
+	"devDependencies": {
+		"@biomejs/biome": "^2.4.6",
+		"@types/bun": "latest",
+		"@typescript/native-preview": "^7.0.0-dev.20260306.1",
+		"typescript": "^5.7.0"
+	}
+}