expo-release 2.3.1 → 2.4.0

package/src/run.ts

@@ -1,22 +1,166 @@
+import { existsSync } from 'node:fs'
+import { dirname, join } from 'node:path'
+
 export type CommandRunner = (command: string[]) => Promise<string>
 
+/**
+ * The app's own eas-cli (node_modules/.bin, searched up to the repository
+ * root) wins over PATH: its lockfile pins the version. `EAS_BIN` wins over both.
+ */
 export function easCommand(...args: string[]): string[] {
 	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]
 }
 
-export async function runCaptured(command: string[]): Promise<string> {
-	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
+const localBins = new Map<string, string | null>()
+
+/** `node_modules/.bin/<name>` from the working directory up to the repository root. */
+export function localBin(name: string): string | null {
+	const cwd = process.cwd()
+	const cacheKey = `${cwd}\0${name}`
+	const cached = localBins.get(cacheKey)
+	if (cached !== undefined) return cached
+	let bin: string | null = 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
+}
+
+/** A failed command. `tail` holds its last non-empty output lines. */
+export class CommandError extends Error {
+	constructor(
+		message: string,
+		readonly tail: string[]
+	) {
+		super(message)
+		this.name = 'CommandError'
+	}
+}
+
+const ERROR_TAIL_LINES = 20
+
+function lastLines(output: string, count = ERROR_TAIL_LINES): string[] {
+	return output
+		.split('\n')
+		.map((line) => line.trimEnd())
+		.filter((line) => line.trim().length > 0)
+		.slice(-count)
+}
+
+// After the command exits, a background process it started can keep the
+// pipes open; stop reading after this long instead of waiting for it.
+const DRAIN_AFTER_EXIT_MS = 1000
+
+function collect(
+	stream: ReadableStream<Uint8Array>,
+	echo: NodeJS.WriteStream | null,
+	sink: string[]
+) {
+	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(() => undefined),
+		text: () => text
+	}
+}
+
+async function spawn(
+	command: string[],
+	echoStdout: boolean,
+	echoStderr = true
+) {
+	const child = Bun.spawn(command, { stdout: 'pipe', stderr: 'pipe' })
+	// Both streams in arrival order, for the failure tail.
+	const combined: string[] = []
+	const out = collect(
+		child.stdout,
+		echoStdout ? process.stdout : null,
+		combined
+	)
+	// stderr reaches the log: EAS prints its warnings and progress there.
+	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: ReturnType<typeof setTimeout> | undefined
+	const timedOut = await Promise.race([
+		drained.then(() => false),
+		new Promise<boolean>((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(''))
+	}
+}
+
+/** Runs a command for its stdout. stderr streams to the log. */
+export async function runCaptured(command: string[]): Promise<string> {
+	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
+}
+
+/** Like runCaptured, but prints nothing: for checks that quote the error. */
+export async function runSilent(command: string[]): Promise<string> {
+	const { stdout, stderr, exitCode, tail } = await spawn(command, false, false)
+	if (exitCode !== 0) {
+		throw new CommandError(
+			describeFailure(command, exitCode, { stderr, stdout }),
+			tail
+		)
+	}
+	return stdout
+}
+
+/** Runs a command with its output in the log. Resolves its stdout. */
+export async function runInherited(command: string[]): Promise<string> {
+	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
 }
@@ -50,23 +194,37 @@ export function describeFailure(
 	return sections.join('\n')
 }
 
-export async function runInherited(command: string[]): Promise<string> {
-	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)`
-		)
+/**
+ * Parses the last JSON document in `output`. `preamble` is whatever came
+ * before it: eas-cli prints warnings to stdout before it switches to JSON-only
+ * output, for example when `npx expo config` failed and it fell back.
+ */
+export function parseJsonDocument(output: string): {
+	value: unknown
+	preamble: string
+} {
+	// A document starts at the beginning of the output or of a line; pretty
+	// printed JSON indents everything after its first line.
+	const starts = [0]
+	for (const match of output.matchAll(/\n(?=[[{])/g)) {
+		starts.push(match.index + 1)
 	}
-	return ''
+	for (const start of starts) {
+		try {
+			return {
+				value: JSON.parse(output.slice(start)) as unknown,
+				preamble: output.slice(0, start).trim()
+			}
+		} catch {}
+	}
+	throw new Error(`Expected JSON output, received:\n${tail(output)}`)
 }
 
+/** Parses JSON output, logging any text printed before it. */
 export function parseJson(output: string): unknown {
-	try {
-		return JSON.parse(output) as unknown
-	} catch {
-		throw new Error(`Expected JSON output, received:\n${output}`)
-	}
+	const { value, preamble } = parseJsonDocument(output)
+	if (preamble) process.stderr.write(`${preamble}\n`)
+	return value
 }
 
 export function getRecord(
@@ -80,7 +238,7 @@ export function getRecord(
 }
 
 export function parseFingerprintHash(output: string): string {
-	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')
 	}
@@ -99,21 +257,85 @@ export function dryRunCommand(command: string[]): void {
 	process.stderr.write(`[dry-run] ${quoteCommand(command)}\n`)
 }
 
+export type Stage =
+	| 'doctor'
+	| 'diff'
+	| 'fingerprint'
+	| 'build list'
+	| 'errored build'
+	| 'fingerprint diff'
+	| 'native build'
+	| 'ota export'
+	| 'ota update'
+	| 'pre-update'
+	| 'post-update'
+	| 'recovery'
+
+/** A failed release step: what ran, and the last lines it printed. */
+export class StageError extends Error {
+	constructor(
+		readonly stage: Stage,
+		message: string,
+		readonly tail: string[] = []
+	) {
+		super(message)
+		this.name = 'StageError'
+	}
+}
+
+/** Runs one release step, logs how long it took, and names it on failure. */
+export async function stage<T>(name: Stage, run: () => Promise<T>): Promise<T> {
+	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\n`)
+	}
+}
+
+/**
+ * The fingerprint fails when eas-cli printed anything before its JSON: that
+ * means the app config did not load and eas-cli fell back to its bundled
+ * `@expo/config`, whose fingerprint may not be the one EAS builds with.
+ * `explainConfig` runs `expo config` to surface the real error.
+ */
 export async function generateFingerprint(
 	input: { platform: string; profile: string },
-	commandRunner: CommandRunner
+	commandRunner: CommandRunner,
+	explainConfig?: () => Promise<string>
 ): Promise<string> {
-	return parseFingerprintHash(
-		await commandRunner(
-			easCommand(
-				'fingerprint:generate',
-				'--platform',
-				input.platform,
-				'--build-profile',
-				input.profile,
-				'--json',
-				'--non-interactive'
-			)
+	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:\n${preamble}`,
+				reason && `expo config said:\n${reason}`
+			]
+				.filter(Boolean)
+				.join('\n'),
+			lastLines(reason || preamble)
+		)
+	}
+	return parseFingerprintHash(output)
 }

package/src/runtime/index.ts

@@ -5,6 +5,8 @@ export {
 } from './error-boundary'
 export {
 	checkForOTAUpdate,
+	getReleaseInfo,
+	type ReleaseInfo,
 	type ReloadApp,
 	type UseOTAUpdatesOptions,
 	useOTAUpdates

package/src/runtime/ota.ts

@@ -1,11 +1,44 @@
 import * as Updates from 'expo-updates'
 import { useEffect, useRef } from 'react'
+import { AppState } from 'react-native'
 
 declare const __DEV__: boolean | undefined
 
 /** Restarts the app on the downloaded update. */
 export type ReloadApp = () => Promise<void>
 
+/** Which release is running, for crash reports and a version screen. */
+export interface ReleaseInfo {
+	/** The running EAS update; null for the build's embedded bundle and in Expo Go. */
+	updateId: string | null
+	runtimeVersion: string | null
+	channel: string | null
+	/** When the running update (or the embedded bundle) was published. */
+	createdAt: Date | null
+	isEmbeddedLaunch: boolean
+}
+
+/** The running release, read from expo-updates. Safe in Expo Go and development. */
+export function getReleaseInfo(): ReleaseInfo {
+	return {
+		updateId: Updates.updateId ?? null,
+		runtimeVersion: Updates.runtimeVersion ?? null,
+		channel: Updates.channel ?? null,
+		createdAt: Updates.createdAt ?? null,
+		isEmbeddedLaunch: Updates.isEmbeddedLaunch === true
+	}
+}
+
+/** Downloads an available update; resolves its id (or '') when it is new. */
+async function downloadUpdate(): Promise<string | null> {
+	const update = await Updates.checkForUpdateAsync()
+	if (!update.isAvailable) return null
+	const result = await Updates.fetchUpdateAsync()
+	if (!result.isNew) return null
+	const id = (result.manifest as { id?: unknown } | undefined)?.id
+	return typeof id === 'string' ? id : ''
+}
+
 /**
  * Checks for an EAS update and downloads it. Calls `onUpdateReady` once a new
  * update is on disk; show a "Restart" prompt there and call `reload` to apply.
@@ -14,10 +47,7 @@ export type ReloadApp = () => Promise<void>
 export async function checkForOTAUpdate(
 	onUpdateReady: (reload: ReloadApp) => void
 ): Promise<boolean> {
-	const update = await Updates.checkForUpdateAsync()
-	if (!update.isAvailable) return false
-	const result = await Updates.fetchUpdateAsync()
-	if (!result.isNew) return false
+	if ((await downloadUpdate()) === null) return false
 	onUpdateReady(() => Updates.reloadAsync())
 	return true
 }
@@ -25,30 +55,77 @@ export async function checkForOTAUpdate(
 export interface UseOTAUpdatesOptions {
 	/** Defaults to off in development and wherever expo-updates is disabled (Expo Go). */
 	enabled?: boolean
-	/** A failed check is retried on the next launch; defaults to ignoring it. */
+	/**
+	 * Check again when the app returns to the foreground, at most once per this
+	 * many minutes. Off by default: an app kept open for days then gets a fix
+	 * only after the OS kills it.
+	 */
+	recheckOnForeground?: number
+	/** A failed check is retried on the next launch or foreground. Defaults to console.warn. */
 	onError?: (error: unknown) => void
 }
 
 /**
- * Checks for an update once per mount. The callbacks are read through refs, so
- * an unstable toast function never re-runs the check or stacks prompts.
+ * Checks for an update once per mount, and on foreground with
+ * `recheckOnForeground`. `onUpdateReady` runs once per downloaded update. The
+ * callbacks are read through refs, so an unstable toast function never re-runs
+ * the check or stacks prompts.
  */
 export function useOTAUpdates(
 	onUpdateReady: (reload: ReloadApp) => void,
 	options: UseOTAUpdatesOptions = {}
 ): void {
 	const {
-		enabled = Updates.isEnabled && !(typeof __DEV__ !== 'undefined' && __DEV__)
+		enabled = Updates.isEnabled && !(typeof __DEV__ !== 'undefined' && __DEV__),
+		recheckOnForeground
 	} = options
 	const callbacks = useRef({ onUpdateReady, onError: options.onError })
 	callbacks.current = { onUpdateReady, onError: options.onError }
-	const checked = useRef(false)
+	const state = useRef({
+		checked: false,
+		running: false,
+		lastCheck: 0,
+		readyId: null as string | null
+	})
 
 	useEffect(() => {
-		if (!enabled || checked.current) return
-		checked.current = true
-		checkForOTAUpdate((reload) =>
-			callbacks.current.onUpdateReady(reload)
-		).catch((error: unknown) => callbacks.current.onError?.(error))
-	}, [enabled])
+		if (!enabled) return
+		const check = () => {
+			const current = state.current
+			if (current.running) return
+			current.running = true
+			current.lastCheck = Date.now()
+			downloadUpdate()
+				.then((id) => {
+					// '' (no manifest id) always counts as a new update.
+					if (id === null || (id !== '' && id === current.readyId)) return
+					current.readyId = id
+					callbacks.current.onUpdateReady(() => Updates.reloadAsync())
+				})
+				.catch((error: unknown) =>
+					(
+						callbacks.current.onError ??
+						((e: unknown) => console.warn('OTA update check failed', e))
+					)(error)
+				)
+				.finally(() => {
+					current.running = false
+				})
+		}
+
+		if (!state.current.checked) {
+			state.current.checked = true
+			check()
+		}
+		if (recheckOnForeground === undefined) return
+		const subscription = AppState.addEventListener('change', (next) => {
+			if (
+				next === 'active' &&
+				Date.now() - state.current.lastCheck >= recheckOnForeground * 60_000
+			) {
+				check()
+			}
+		})
+		return () => subscription.remove()
+	}, [enabled, recheckOnForeground])
 }

package/src/runtime/push.ts

@@ -23,7 +23,10 @@ export interface PushNotificationsOptions {
 	onError?: (message: string, error: unknown) => void
 	/** Defaults to what expo-notifications reads from the app config. */
 	projectId?: string
-	/** Android channel `default`, needed for heads-up notifications. */
+	/**
+	 * Android channel `default`, needed for heads-up notifications. Call
+	 * `setAndroidChannel` again when its texts depend on the locale.
+	 */
 	androidChannel?: Notifications.NotificationChannelInput
 	/** How notifications show while the app is in the foreground. */
 	foregroundBehavior?: Notifications.NotificationBehavior
@@ -34,7 +37,10 @@ export interface PushNotificationsOptions {
 
 export interface NotificationListeners {
 	onReceived?: (notification: Notifications.Notification) => void
-	/** Also called with the response that launched the app, if any. */
+	/**
+	 * Also called with the response that launched the app, if any. Each
+	 * response is delivered once per app start, however often `listen` runs.
+	 */
 	onResponse?: (response: Notifications.NotificationResponse) => void
 }
 
@@ -66,18 +72,29 @@ export function createPushNotifications(options: PushNotificationsOptions) {
 			}
 	})
 	// Channels exist only on Android; elsewhere this resolves to null.
-	Notifications.setNotificationChannelAsync(
-		'default',
-		options.androidChannel ?? {
+	function setAndroidChannel(
+		channel: Notifications.NotificationChannelInput = {
 			name: 'Default',
 			importance: Notifications.AndroidImportance.HIGH,
 			vibrationPattern: [0, 250, 250, 250]
 		}
-	).catch((error: unknown) =>
-		onError('Failed to create the notification channel', error)
-	)
+	) {
+		return Notifications.setNotificationChannelAsync('default', channel)
+			.then(() => undefined)
+			.catch((error: unknown) =>
+				onError('Failed to create the notification channel', error)
+			)
+	}
+	void setAndroidChannel(options.androidChannel)
 
 	let pendingPrompt: Promise<boolean> | null = null
+	// Responses already handed to onResponse. Every getLastNotificationResponse
+	// call returns the last one again, so a replay is skipped once delivered;
+	// live taps always go through. A repeating notification keeps its
+	// identifier, so the date is part of the key.
+	const deliveredResponses = new Set<string>()
+	const responseKey = (response: Notifications.NotificationResponse) =>
+		`${response.notification?.request?.identifier}:${response.notification?.date}:${response.actionIdentifier}`
 
 	const getPermissionStatus = () => Notifications.getPermissionsAsync()
 
@@ -181,6 +198,8 @@ export function createPushNotifications(options: PushNotificationsOptions) {
 		requestPermissions,
 		getPushToken,
 		syncToken,
+		/** Recreates the Android `default` channel, for example after a locale change. */
+		setAndroidChannel,
 
 		/**
 		 * Asks for push once per install (after sign-in, say), then registers the
@@ -205,7 +224,11 @@ export function createPushNotifications(options: PushNotificationsOptions) {
 			return true
 		},
 
-		/** Removes this device's token from your backend. */
+		/**
+		 * Removes this device's token from your backend, and stops `listen` from
+		 * re-registering it. Rejects when `registerDevice(null)` does, so a
+		 * settings screen can show the failure; catch it on sign-out.
+		 */
 		async disable() {
 			await registerDevice(null)
 			// KeyValueStorage has no removeItem; an empty token means none was sent.
@@ -222,16 +245,26 @@ export function createPushNotifications(options: PushNotificationsOptions) {
 					onError('Failed to refresh the push token', error)
 				)
 			void refresh()
+			const deliver =
+				onResponse &&
+				((response: Notifications.NotificationResponse) => {
+					deliveredResponses.add(responseKey(response))
+					onResponse(response)
+				})
 			const subscriptions = [
 				Notifications.addPushTokenListener(refresh),
 				onReceived && Notifications.addNotificationReceivedListener(onReceived),
-				onResponse &&
-					Notifications.addNotificationResponseReceivedListener(onResponse)
+				deliver &&
+					Notifications.addNotificationResponseReceivedListener(deliver)
 			]
-			const launchResponse = onResponse
+			const launchResponse = deliver
 				? Notifications.getLastNotificationResponse()
 				: null
-			if (launchResponse) onResponse?.(launchResponse)
+			if (
+				launchResponse &&
+				!deliveredResponses.has(responseKey(launchResponse))
+			)
+				deliver?.(launchResponse)
 			return () => {
 				for (const subscription of subscriptions) subscription?.remove()
 			}

package/src/runtime/react-native.d.ts

@@ -0,0 +1,10 @@
+// The one react-native API the runtime uses. react-native is an optional peer
+// that every Expo app has; this keeps it out of the devDependencies.
+declare module 'react-native' {
+	export const AppState: {
+		addEventListener(
+			type: 'change',
+			listener: (state: 'active' | 'background' | 'inactive' | string) => void
+		): { remove(): void }
+	}
+}

package/src/source-maps.ts

@@ -1,12 +1,15 @@
 import { exists } from 'node:fs/promises'
 import type { ReleasePlatform } from './args'
+import { localBin } from './run'
 
 export const SOURCE_MAP_OUTPUT_DIR = 'dist'
 
+/** `EXPO_BIN`, else the app's own expo CLI, else `bunx expo`. */
 export function expoCommand(...args: string[]): string[] {
 	const bin = process.env.EXPO_BIN?.trim()
 	if (bin && bin.length > 0) return [bin, ...args]
-	return ['bunx', 'expo', ...args]
+	const local = localBin('expo')
+	return local ? [local, ...args] : ['bunx', 'expo', ...args]
 }
 
 export function sourceMapExportCommand(platform: ReleasePlatform): string[] {