@better-update/cli 0.16.0 → 0.17.0

package/dist/index.mjs

@@ -14,12 +14,13 @@ import { createServer } from "node:http";
 import { maxBy, uniqBy } from "es-toolkit";
 import { createHash, randomBytes, randomUUID } from "node:crypto";
 import forge from "node-forge";
-import { createReadStream, existsSync, readFileSync, writeFileSync } from "node:fs";
+import { createReadStream, existsSync, promises, readFileSync, writeFileSync } from "node:fs";
 import { spawn as spawn$1 } from "node-pty";
 import chalk from "chalk";
 import os from "node:os";
 import plistMod from "@expo/plist";
 import { ExpoRunFormatter } from "@expo/xcpretty";
+import ignore from "ignore";
 import { Buffer as Buffer$1 } from "node:buffer";
 import { getFormattedSerialNumber, getX509Certificate, parsePKCS12 } from "@expo/pkcs12";
 import qrcode from "qrcode-terminal";
@@ -30,7 +31,7 @@ var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 //#endregion
 //#region package.json
-var version = "0.16.0";
+var version = "0.17.0";
 
 //#endregion
 //#region src/lib/interactive-mode.ts
@@ -1665,6 +1666,7 @@ var InvalidArgumentError = class extends Data.TaggedError("InvalidArgumentError"
 var InteractiveProhibitedError = class extends Data.TaggedError("InteractiveProhibitedError") {};
 var CredentialsJsonError = class extends Data.TaggedError("CredentialsJsonError") {};
 var DirtyRepoError = class extends Data.TaggedError("DirtyRepoError") {};
+var StagingError = class extends Data.TaggedError("StagingError") {};
 
 //#endregion
 //#region src/lib/format-error.ts
@@ -6520,6 +6522,131 @@ const detectPlatform = (explicit, config) => Effect.gen(function* () {
 	})));
 });
 
+//#endregion
+//#region src/lib/project-staging.ts
+const LOCKFILES = [
+	["bun.lock", "bun"],
+	["bun.lockb", "bun"],
+	["pnpm-lock.yaml", "pnpm"],
+	["yarn.lock", "yarn"],
+	["package-lock.json", "npm"]
+];
+/**
+* Paths never copied into staging — covers generated native build outputs and
+* dependency dirs that must be reinstalled fresh in staging.
+*/
+const ALWAYS_IGNORE = [
+	"node_modules",
+	".git",
+	"ios/build",
+	"ios/Pods",
+	"ios/DerivedData",
+	"android/build",
+	"android/app/build",
+	"android/.gradle",
+	"android/.kotlin",
+	".expo",
+	".gradle",
+	".turbo",
+	"dist"
+];
+const findLockfile = (fs, dir) => Effect.gen(function* () {
+	for (const [name, pm] of LOCKFILES) if (yield* fs.exists(path.join(dir, name)).pipe(Effect.catchAll(() => Effect.succeed(false)))) return pm;
+});
+const walkUpForLockfile = (startCwd, dir) => Effect.gen(function* () {
+	const pm = yield* findLockfile(yield* FileSystem.FileSystem, dir);
+	if (pm !== void 0) return {
+		workspaceRoot: dir,
+		packageManager: pm
+	};
+	const parent = path.dirname(dir);
+	if (parent === dir) return {
+		workspaceRoot: startCwd,
+		packageManager: "bun"
+	};
+	return yield* walkUpForLockfile(startCwd, parent);
+});
+/**
+* Walk up from `cwd` to the first ancestor directory containing a lockfile.
+* That directory is the install root (monorepo workspace root or the app dir
+* itself in single-app layouts). Defaults to `cwd` + bun when no lockfile is
+* found anywhere up to the volume root.
+*/
+const detectWorkspaceRoot = (cwd) => walkUpForLockfile(cwd, cwd);
+/**
+* Build an `Ignore` matcher for the workspace root. `.easignore` REPLACES
+* `.gitignore` when present (matches EAS semantics); otherwise `.gitignore`
+* is layered on top of the always-ignore baseline.
+*/
+const buildIgnoreInstance = (workspaceRoot) => Effect.gen(function* () {
+	const fs = yield* FileSystem.FileSystem;
+	const ig = ignore();
+	ig.add([...ALWAYS_IGNORE]);
+	const easignorePath = path.join(workspaceRoot, ".easignore");
+	if (yield* fs.exists(easignorePath).pipe(Effect.catchAll(() => Effect.succeed(false)))) {
+		const content = yield* fs.readFileString(easignorePath).pipe(Effect.catchAll(() => Effect.succeed("")));
+		ig.add(content);
+		return ig;
+	}
+	const gitignorePath = path.join(workspaceRoot, ".gitignore");
+	if (yield* fs.exists(gitignorePath).pipe(Effect.catchAll(() => Effect.succeed(false)))) {
+		const content = yield* fs.readFileString(gitignorePath).pipe(Effect.catchAll(() => Effect.succeed("")));
+		ig.add(content);
+	}
+	return ig;
+});
+const copyProjectTree = (params) => Effect.tryPromise({
+	try: async () => {
+		await promises.cp(params.source, params.dest, {
+			recursive: true,
+			dereference: false,
+			filter: (src) => {
+				const rel = path.relative(params.source, src);
+				if (rel === "") return true;
+				const posixRel = rel.split(path.sep).join("/");
+				return !params.ig.ignores(posixRel);
+			}
+		});
+	},
+	catch: (cause) => new StagingError({ message: `Failed to copy project to staging dir: ${formatCause(cause)}` })
+});
+const runInstall = (params) => runStep({
+	command: params.packageManager,
+	args: ["install"],
+	cwd: params.stagingRoot,
+	env: params.env
+}, `${params.packageManager} install`);
+/**
+* Copy the user's project (or workspace root, for monorepos) into a fresh
+* directory inside `tempDir`, then run `<pm> install` there. The build then
+* runs entirely against the staged copy — the user's working tree stays clean
+* regardless of what `expo prebuild`, `pod install`, or `gradlew` write.
+*/
+const prepareStagingProject = (input) => Effect.gen(function* () {
+	const runtime = yield* CliRuntime;
+	const { workspaceRoot, packageManager } = yield* detectWorkspaceRoot(input.userCwd);
+	const relAppPath = path.relative(workspaceRoot, input.userCwd);
+	const stagingRoot = path.join(input.tempDir, "project");
+	const projectRoot = relAppPath === "" ? stagingRoot : path.join(stagingRoot, relAppPath);
+	yield* Console.log(`Staging build into ${stagingRoot}${relAppPath === "" ? "" : ` (app: ${relAppPath})`}`);
+	yield* copyProjectTree({
+		source: workspaceRoot,
+		dest: stagingRoot,
+		ig: yield* buildIgnoreInstance(workspaceRoot)
+	});
+	yield* runInstall({
+		stagingRoot,
+		packageManager,
+		env: yield* runtime.commandEnvironment(input.envVars)
+	});
+	return {
+		stagingRoot,
+		projectRoot,
+		packageManager,
+		relAppPath
+	};
+});
+
 //#endregion
 //#region src/lib/repo-clean.ts
 const MAX_FILES_SHOWN = 10;
@@ -6669,35 +6796,40 @@ const resolveProfileName = (projectRoot, requested) => Effect.gen(function* () {
 });
 const runBuildWorkflow = (options) => Effect.scoped(Effect.gen(function* () {
 	const api = yield* apiClient;
-	const projectRoot = yield* (yield* CliRuntime).cwd;
+	const userCwd = yield* (yield* CliRuntime).cwd;
 	yield* ensureRepoClean({
-		projectRoot,
+		projectRoot: userCwd,
 		allowDirty: options.allowDirty ?? false,
 		label: "build"
 	});
-	const baseConfig = yield* readExpoConfig(projectRoot);
+	const baseConfig = yield* readExpoConfig(userCwd);
 	const projectId = yield* extractProjectId(baseConfig);
 	const platform = yield* detectPlatform(options.platform, baseConfig);
-	const profile = yield* readBuildProfile(projectRoot, yield* resolveProfileName(projectRoot, options.profileName));
+	const profile = yield* readBuildProfile(userCwd, yield* resolveProfileName(userCwd, options.profileName));
 	const envVars = yield* pullEnvVars(api, {
 		projectId,
 		environment: profile.environment
 	});
 	yield* applyAutoIncrement({
-		projectRoot,
+		projectRoot: userCwd,
 		platform,
-		config: yield* readExpoConfig(projectRoot, envVars),
+		config: yield* readExpoConfig(userCwd, envVars),
 		...platform === "ios" && profile.ios?.autoIncrement !== void 0 ? { iosMode: profile.ios.autoIncrement } : {},
 		...platform === "android" && profile.android?.autoIncrement !== void 0 ? { androidMode: profile.android.autoIncrement } : {}
 	});
-	const appMeta = yield* readAppMeta(yield* readExpoConfig(projectRoot, envVars), platform);
+	const appMeta = yield* readAppMeta(yield* readExpoConfig(userCwd, envVars), platform);
 	const runtimeVersion = yield* resolveRuntimeVersion({
 		raw: appMeta.rawRuntimeVersion,
 		appVersion: appMeta.appVersion,
-		projectRoot
+		projectRoot: userCwd
 	});
-	if (options.clearCache) yield* clearBuildCaches(projectRoot);
+	if (options.clearCache) yield* clearBuildCaches(userCwd);
 	const tempDir = yield* acquireBuildTempDir;
+	const staging = yield* prepareStagingProject({
+		userCwd,
+		tempDir,
+		envVars
+	});
 	yield* Console.log(`Building ${platform} artifact for profile "${profile.name}" (runtimeVersion=${runtimeVersion})`);
 	const { build, target, bundleId } = yield* runPlatformBuild({
 		api,
@@ -6707,14 +6839,14 @@ const runBuildWorkflow = (options) => Effect.scoped(Effect.gen(function* () {
 		appMeta,
 		envVars,
 		projectId,
-		projectRoot,
+		projectRoot: staging.projectRoot,
 		tempDir
 	});
 	yield* Console.log(`Artifact produced: ${build.artifactPath}`);
 	let exportedArtifactPath = void 0;
 	if (options.output !== void 0) {
 		const fs = yield* FileSystem.FileSystem;
-		const outputPath = path.resolve(projectRoot, options.output);
+		const outputPath = path.resolve(userCwd, options.output);
 		const outputDir = path.dirname(outputPath);
 		yield* fs.makeDirectory(outputDir, { recursive: true }).pipe(Effect.mapError((cause) => new BuildProfileError({ message: `Failed to create output directory: ${formatCause(cause)}` })));
 		yield* fs.copyFile(build.artifactPath, outputPath).pipe(Effect.mapError((cause) => new BuildProfileError({ message: `Failed to copy artifact to ${outputPath}: ${formatCause(cause)}` })));
@@ -6731,7 +6863,7 @@ const runBuildWorkflow = (options) => Effect.scoped(Effect.gen(function* () {
 		]);
 		return;
 	}
-	const rawGitContext = yield* readGitContext(projectRoot);
+	const rawGitContext = yield* readGitContext(userCwd);
 	const gitContext = {
 		...rawGitContext.ref === void 0 ? {} : { ref: rawGitContext.ref },
 		...rawGitContext.commit === void 0 ? {} : { commit: rawGitContext.commit },
@@ -6875,7 +7007,8 @@ const BUILD_EXIT_EXTRAS = {
 	PresignedUrlExpiredError: 7,
 	CompleteError: 7,
 	EnvExportError: 7,
-	DirtyRepoError: 3
+	DirtyRepoError: 3,
+	StagingError: 6
 };
 const buildCommand = defineCommand({
 	meta: {