@better-update/cli 0.47.5 → 0.48.0

package/dist/index.mjs

@@ -35,7 +35,7 @@ var __require = /* #__PURE__ */ (() => createRequire(import.meta.url))();
 
 //#endregion
 //#region package.json
-var version = "0.47.5";
+var version = "0.48.0";
 
 //#endregion
 //#region src/lib/interactive-mode.ts
@@ -22111,6 +22111,109 @@ const renderSigningGradle = ({ keystorePath, storePassword, keyAlias, keyPasswor
 }
 `;
 
+//#endregion
+//#region src/lib/dotenv-file.ts
+/** Escape a string so it can be embedded as a literal inside a RegExp. */
+const escapeRegExp = (value) => value.replaceAll(/[.*+?^${}()|[\]\\]/gu, String.raw`\$&`);
+/**
+* Set or append `KEY=value` in a `.env` file body, mirroring the line-based
+* reader used by react-native-config (`dotenv.gradle` on Android,
+* `BuildDotenvConfig.rb` on iOS): values are written raw and single-line, an
+* existing key is replaced in place, a new key is appended at the end. Returns
+* the updated body.
+*/
+const setEnvVar = (content, key, value) => {
+	const re = new RegExp(String.raw`^${escapeRegExp(key)}=.*$`, "mu");
+	return re.test(content) ? content.replace(re, `${key}=${value}`) : `${content.replace(/\n*$/u, "")}\n${key}=${value}\n`;
+};
+/** Apply a batch of `KEY=value` upserts in order (later entries win on a dup key). */
+const setEnvVars = (content, entries) => entries.reduce((acc, [key, value]) => setEnvVar(acc, key, value), content);
+
+//#endregion
+//#region src/lib/android-version-sync.ts
+const CODE_LITERAL = /\bversionCode\s+(?<code>\d+)/u;
+const NAME_LITERAL = /\bversionName\s+(?<quote>["'])(?<name>[^"'\n]*)\k<quote>/u;
+const CODE_ENV = /\bversionCode\b[^\n]*?\.env\.get\(\s*["'](?<key>[^"']+)["']\s*\)/u;
+const NAME_ENV = /\bversionName\b[^\n]*?\.env\.get\(\s*["'](?<key>[^"']+)["']\s*\)/u;
+/**
+* Materialize one version field: patch a `build.gradle` literal in place, or
+* collect the referenced `.env` key when the value is `project.env.get(...)`.
+*/
+const planField = (gradle, literal, env, value, rewriteLiteral) => {
+	if (literal.test(gradle)) return {
+		gradle: gradle.replace(literal, rewriteLiteral),
+		matched: true
+	};
+	const key = env.exec(gradle)?.groups?.["key"];
+	if (key !== void 0) return {
+		gradle,
+		envKey: [key, value],
+		matched: true
+	};
+	return {
+		gradle,
+		matched: false
+	};
+};
+/** Plan both version fields against the build.gradle content. */
+const planVersions = (gradle, params) => {
+	const envKeys = [];
+	const unresolved = [];
+	let next = gradle;
+	const apply = (value, literal, env, kind) => {
+		if (value === void 0) return;
+		const outcome = planField(next, literal, env, value, kind === "versionCode" ? () => `versionCode ${value}` : (match) => match.replace(NAME_LITERAL, (_full, quote) => `versionName ${quote}${value}${quote}`));
+		next = outcome.gradle;
+		if (outcome.envKey) envKeys.push(outcome.envKey);
+		else if (!outcome.matched) unresolved.push(kind);
+	};
+	apply(params.versionCode, CODE_LITERAL, CODE_ENV, "versionCode");
+	apply(params.versionName, NAME_LITERAL, NAME_ENV, "versionName");
+	return {
+		gradle: next,
+		envKeys,
+		unresolved
+	};
+};
+const writeEnvKeys = (envPath, envKeys) => Effect.gen(function* () {
+	const fs = yield* FileSystem.FileSystem;
+	const current = yield* fs.readFileString(envPath).pipe(Effect.orElseSucceed(() => ""));
+	const next = envKeys.reduce((acc, [key, value]) => setEnvVar(acc, key, value), current);
+	yield* fs.writeFileString(envPath, next).pipe(Effect.orElseSucceed(() => void 0));
+});
+const reportResult = (params, patchedGradle, envKeys) => {
+	return printHuman(`Applied eas.json version (${[...params.versionName === void 0 ? [] : [`versionName=${params.versionName}`], ...params.versionCode === void 0 ? [] : [`versionCode=${params.versionCode}`]].join(", ")}) to ${[...patchedGradle ? ["build.gradle"] : [], ...envKeys.length === 0 ? [] : [`.env (${envKeys.map(([key]) => key).join(", ")})`]].join(" + ")}`);
+};
+/**
+* Materialize an eas.json Android version / versionCode override into the staged
+* project so the built APK/AAB matches eas.json. Two shapes are supported:
+*
+* - Literal `versionCode` / `versionName` in `android/app/build.gradle` → the
+*   literal is patched in place.
+* - react-native-config `project.env.get("KEY")` → the referenced key is written
+*   into the staged `.env`, which the dotenv.gradle reader consumes at build time.
+*
+* Best-effort and non-fatal: a project whose version is wired some other way is
+* left untouched with a warning, never failing the build. Expo and custom builds
+* never reach here (the caller gates on non-Expo, native-strategy builds).
+*/
+const applyAndroidVersion = (params) => Effect.gen(function* () {
+	if (params.versionName === void 0 && params.versionCode === void 0) return;
+	const fs = yield* FileSystem.FileSystem;
+	const gradlePath = path.join(params.projectRoot, "android", "app", "build.gradle");
+	const original = yield* fs.readFileString(gradlePath).pipe(Effect.orElseSucceed(() => void 0));
+	if (original === void 0) {
+		yield* printWarn(`Could not read ${gradlePath} to apply the eas.json version override — leaving native version as-is.`);
+		return;
+	}
+	const plan = planVersions(original, params);
+	const patchedGradle = plan.gradle !== original;
+	if (patchedGradle) yield* fs.writeFileString(gradlePath, plan.gradle).pipe(Effect.orElseSucceed(() => void 0));
+	if (plan.envKeys.length > 0) yield* writeEnvKeys(path.join(params.projectRoot, ".env"), plan.envKeys);
+	if (patchedGradle || plan.envKeys.length > 0) yield* reportResult(params, patchedGradle, plan.envKeys);
+	if (plan.unresolved.length > 0) yield* printWarn(`Could not locate ${plan.unresolved.join(" / ")} in android/app/build.gradle (no literal or react-native-config \`project.env.get(...)\` form found) — the built artifact may not reflect the eas.json version.`);
+});
+
 //#endregion
 //#region src/lib/string-utils.ts
 const capitalize = (value) => {
@@ -23211,6 +23314,13 @@ const runGradleBuild = (input, commandEnv) => Effect.gen(function* () {
 	const moduleName = input.androidProfile.module ?? "app";
 	const androidDir = path.join(input.projectRoot, "android");
 	yield* fixGradlew(androidDir, input.strategy !== "expo");
+	if (input.nativeVersion !== void 0) yield* applyAndroidVersion({
+		projectRoot: input.projectRoot,
+		...compact({
+			versionName: input.nativeVersion.versionName,
+			versionCode: input.nativeVersion.versionCode
+		})
+	});
 	const credentials = yield* resolveAndroidCredentials(input);
 	const gradleArgs = credentials === void 0 ? [] : yield* Effect.gen(function* () {
 		const fs = yield* FileSystem.FileSystem;
@@ -23949,8 +24059,15 @@ const parseProject$1 = (pbxprojPath) => Effect.try({
 * spaces, brackets or non-identifier characters needs explicit quoting.
 */
 const quote = (value) => `"${value.replaceAll("\"", String.raw`\"`)}"`;
+/**
+* Version values (e.g. `6.0.4`, `17`) are normally emitted unquoted in pbxproj.
+* Keep them bare when they are a safe token to minimize diff noise versus the
+* committed project; fall back to quoting only for unusual values.
+*/
+const SAFE_PBX_TOKEN = /^[A-Za-z0-9._-]+$/u;
+const pbxValue = (value) => SAFE_PBX_TOKEN.test(value) ? value : quote(value);
 const SDK_CONDITIONAL_IDENTITY_KEYS = ["\"CODE_SIGN_IDENTITY[sdk=iphoneos*]\"", "CODE_SIGN_IDENTITY[sdk=iphoneos*]"];
-const mutateConfig = (project, configUuid, settings) => {
+const mutateConfig = (project, configUuid, settings, versions) => {
 	const cfg = project.pbxXCBuildConfigurationSection()[configUuid];
 	if (!cfg || typeof cfg === "string") return false;
 	cfg.buildSettings["CODE_SIGN_STYLE"] = "Manual";
@@ -23959,12 +24076,16 @@ const mutateConfig = (project, configUuid, settings) => {
 	cfg.buildSettings["PROVISIONING_PROFILE_SPECIFIER"] = quote(settings.profileSpecifier);
 	delete cfg.buildSettings["PROVISIONING_PROFILE"];
 	for (const key of SDK_CONDITIONAL_IDENTITY_KEYS) delete cfg.buildSettings[key];
+	if (versions?.marketingVersion !== void 0) cfg.buildSettings["MARKETING_VERSION"] = pbxValue(versions.marketingVersion);
+	if (versions?.currentProjectVersion !== void 0) cfg.buildSettings["CURRENT_PROJECT_VERSION"] = pbxValue(versions.currentProjectVersion);
 	return true;
 };
 /**
 * Write `CODE_SIGN_STYLE=Manual`, `DEVELOPMENT_TEAM`, `CODE_SIGN_IDENTITY`, and
 * `PROVISIONING_PROFILE_SPECIFIER` into the specified XCBuildConfiguration
-* entries of the project under `iosDir`, then serialize back to disk.
+* entries of the project under `iosDir`, then serialize back to disk. When an
+* entry carries `versions`, `MARKETING_VERSION` / `CURRENT_PROJECT_VERSION` are
+* written into the same configuration(s) in the one pass.
 *
 * Only mutates the main app project — `Pods.xcodeproj` is left untouched. The
 * caller is responsible for ensuring each entry's `buildConfigurationUuids`
@@ -23976,7 +24097,7 @@ const applyTargetSigning = (options) => Effect.gen(function* () {
 	const projectDir = yield* findXcodeProjectDir$1(options.iosDir);
 	const pbxprojPath = path.join(projectDir, "project.pbxproj");
 	const project = yield* parseProject$1(pbxprojPath);
-	for (const entry of options.entries) for (const configUuid of entry.buildConfigurationUuids) if (!mutateConfig(project, configUuid, entry.settings)) return yield* new XcodeProjectError({ message: `Build configuration ${configUuid} not found for target "${entry.targetName}" in ${pbxprojPath}.` });
+	for (const entry of options.entries) for (const configUuid of entry.buildConfigurationUuids) if (!mutateConfig(project, configUuid, entry.settings, entry.versions)) return yield* new XcodeProjectError({ message: `Build configuration ${configUuid} not found for target "${entry.targetName}" in ${pbxprojPath}.` });
 	const serialized = yield* Effect.try({
 		try: () => project.writeSync(),
 		catch: (cause) => new XcodeProjectError({ message: `Failed to serialize ${pbxprojPath}: ${cause instanceof Error ? cause.message : String(cause)}` })
@@ -24139,6 +24260,30 @@ const installProvisioningProfile = ({ profilePath }) => Effect.acquireRelease(Ef
 	installedPath
 })));
 
+//#endregion
+//#region src/lib/ios-signing-entries.ts
+/**
+* Render the pbxproj signing entries for every installed target. When
+* `nativeVersion` is provided it is attached to ALL signed targets (app +
+* extensions): App Store validation rejects a bundled extension whose
+* CFBundleVersion / CFBundleShortVersionString differs from the host app, so the
+* version must move on every target together (matches `expo prebuild` and the
+* prior per-repo sync-version workaround).
+*
+* Pure and dependency-free so the build pipeline and its tests share one source
+* of truth for the entry shape without pulling in the credentials stack.
+*/
+const buildSigningEntries = (params) => params.installedTargets.map(({ target, installed }) => ({
+	targetName: target.targetName,
+	buildConfigurationUuids: target.buildConfigurationUuids,
+	settings: {
+		teamId: installed.teamId,
+		signingIdentity: params.signingIdentity,
+		profileSpecifier: installed.name
+	},
+	...params.nativeVersion ? { versions: params.nativeVersion } : {}
+}));
+
 //#endregion
 //#region src/lib/post-build-validation.ts
 const validateOneBundle = (bundleDir, expectedByBundleId, expectedTeamId) => Effect.gen(function* () {
@@ -24601,15 +24746,11 @@ const runIosDeviceBuild = (input) => Effect.gen(function* () {
 	const installedTargets = yield* installPerTarget(signedTargets, credentials, input.credentialsSource);
 	yield* applyTargetSigning({
 		iosDir,
-		entries: installedTargets.map(({ target, installed }) => ({
-			targetName: target.targetName,
-			buildConfigurationUuids: target.buildConfigurationUuids,
-			settings: {
-				teamId: installed.teamId,
-				signingIdentity: keychain.signingIdentity,
-				profileSpecifier: installed.name
-			}
-		}))
+		entries: buildSigningEntries({
+			installedTargets,
+			signingIdentity: keychain.signingIdentity,
+			nativeVersion: input.nativeVersion
+		})
 	});
 	const archivePath = path.join(tempDir, "build.xcarchive");
 	const archiveCmd = {
@@ -24748,6 +24889,59 @@ const resolveIosStrategy = (profile, projectType) => {
 	return projectType === "expo" ? "expo" : "xcode";
 };
 
+//#endregion
+//#region src/lib/env-materialize.ts
+/**
+* Does the staged project consume a root `.env` at native-build time via
+* react-native-config? Only those projects need env materialization:
+*
+* - Expo reads `process.env` / app.config and regenerates native at prebuild.
+* - A bare project WITHOUT react-native-config reads its config another way
+*   (process.env injection / hardcoded), so writing a stray `.env` there could
+*   shadow unrelated config — leave it untouched.
+*
+* react-native-config is always a direct dependency when used, so package.json is
+* the reliable signal. Mirrors `hasExpoDependency` in detect-project-type.ts; a
+* missing/unparseable package.json is treated as "no".
+*/
+const usesReactNativeConfig = (projectRoot) => Effect.gen(function* () {
+	const text = yield* (yield* FileSystem.FileSystem).readFileString(path.join(projectRoot, "package.json")).pipe(Effect.orElseSucceed(() => ""));
+	if (text.length === 0) return false;
+	const pkg = asRecord(yield* Effect.try(() => JSON.parse(text)).pipe(Effect.orElseSucceed(() => void 0)));
+	const deps = asRecord(pkg?.["dependencies"]);
+	const devDeps = asRecord(pkg?.["devDependencies"]);
+	return deps?.["react-native-config"] !== void 0 || devDeps?.["react-native-config"] !== void 0;
+});
+/**
+* Materialize the decrypted environment into the staged project's `.env` so a
+* bare react-native-config build reads the SAME values the Expo path gets via
+* `process.env`. react-native-config reads the `.env` FILE at build time (not
+* `process.env`), so without this a bare project would ship with whatever `.env`
+* was committed (or none) regardless of the server's environment.
+*
+* Supports both bare shapes:
+* - WITH react-native-config → values are merged into `.env` (server wins on a
+*   key collision; any committed local-only keys are preserved).
+* - WITHOUT react-native-config → no-op; the build still gets the env via the
+*   existing process.env injection, so nothing is lost and no stray file appears.
+*
+* Best-effort and non-fatal. Expo never reaches here (the caller gates on
+* non-Expo). An empty env set is a clean no-op, so this is safe to ship before
+* the server's env-vault is populated.
+*/
+const materializeEnvFile = (params) => Effect.gen(function* () {
+	const entries = Object.entries(params.envVars);
+	if (entries.length === 0) return;
+	if (!(yield* usesReactNativeConfig(params.projectRoot))) return;
+	const fs = yield* FileSystem.FileSystem;
+	const envPath = path.join(params.projectRoot, ".env");
+	const current = yield* fs.readFileString(envPath).pipe(Effect.orElseSucceed(() => ""));
+	const next = setEnvVars(current, entries);
+	if (next === current) return;
+	yield* fs.writeFileString(envPath, next).pipe(Effect.orElseSucceed(() => void 0));
+	yield* printHuman(`Materialized ${String(entries.length)} environment variable(s) into .env for react-native-config.`);
+});
+
 //#endregion
 //#region src/lib/gradle-config.ts
 const isValidAndroidPackageName = Schema.is(AndroidPackageName);
@@ -24835,6 +25029,11 @@ const runIosPlatformBuild = (input) => Effect.gen(function* () {
 		bundleIdentifier: iosBundleId,
 		distribution: iosProfile.distribution
 	}, { freezeCredentials: input.freezeCredentials });
+	const iosOverride = profile.ios.metaOverride;
+	const nativeVersion = input.projectType !== "expo" && (iosOverride?.version !== void 0 || iosOverride?.buildNumber !== void 0) ? compact({
+		marketingVersion: appMeta.appVersion,
+		currentProjectVersion: appMeta.buildNumber
+	}) : void 0;
 	return {
 		build: yield* runIosBuild({
 			api,
@@ -24850,7 +25049,10 @@ const runIosPlatformBuild = (input) => Effect.gen(function* () {
 			rawOutput: input.rawOutput,
 			freezeCredentials: input.freezeCredentials,
 			updateChannel: input.updateChannel,
-			...compact({ customCommand: profile.customCommand?.ios })
+			...compact({
+				customCommand: profile.customCommand?.ios,
+				nativeVersion
+			})
 		}),
 		target: isSimulator ? {
 			platform: "ios",
@@ -24880,6 +25082,11 @@ const runAndroidPlatformBuild = (input) => Effect.gen(function* () {
 		projectId,
 		applicationIdentifier
 	}, { freezeCredentials: input.freezeCredentials });
+	const androidOverride = profile.android.metaOverride;
+	const nativeVersion = input.projectType !== "expo" && (androidOverride?.version !== void 0 || androidOverride?.versionCode !== void 0) ? compact({
+		versionName: appMeta.appVersion,
+		versionCode: appMeta.buildNumber
+	}) : void 0;
 	return {
 		build: yield* runAndroidBuild({
 			api,
@@ -24895,7 +25102,10 @@ const runAndroidPlatformBuild = (input) => Effect.gen(function* () {
 			strategy,
 			packageManager: input.packageManager,
 			updateChannel: input.updateChannel,
-			...compact({ customCommand: profile.customCommand?.android })
+			...compact({
+				customCommand: profile.customCommand?.android,
+				nativeVersion
+			})
 		}),
 		target: androidProfile.format === "aab" ? {
 			platform: "android",
@@ -24910,6 +25120,10 @@ const runAndroidPlatformBuild = (input) => Effect.gen(function* () {
 	};
 });
 const runPlatformBuild = (input) => Effect.gen(function* () {
+	if (input.projectType !== "expo") yield* materializeEnvFile({
+		projectRoot: input.projectRoot,
+		envVars: input.appEnvVars
+	});
 	return input.platform === "ios" ? yield* runIosPlatformBuild(input) : yield* runAndroidPlatformBuild(input);
 });
 
@@ -25245,6 +25459,7 @@ const runBuildWorkflow = (options) => Effect.scoped(Effect.gen(function* () {
 		projectType,
 		appMeta,
 		envVars: buildEnv,
+		appEnvVars: envVars,
 		projectId,
 		projectRoot: staging.projectRoot,
 		tempDir,