@better-update/cli 0.15.4 → 0.17.0

package/dist/index.mjs

@@ -2,7 +2,7 @@
 import { createRequire } from "node:module";
 import { spawn, spawnSync } from "node:child_process";
 import { defineCommand, runMain } from "citty";
-import { Console, Context, Data, Deferred, Duration, Effect, Fiber, Layer, Match, Option, ParseResult, Schema, Stream } from "effect";
+import { Console, Context, Data, Deferred, Duration, Effect, Layer, Match, Option, ParseResult, Schema } from "effect";
 import { Command, FetchHttpClient, FileSystem, HttpApi, HttpApiClient, HttpApiEndpoint, HttpApiGroup, HttpApiMiddleware, HttpApiSchema, HttpApiSecurity, HttpClient, HttpClientRequest, OpenApi, Path } from "@effect/platform";
 import { NodeContext } from "@effect/platform-node";
 import path, { join } from "node:path";
@@ -14,10 +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";
@@ -28,7 +31,7 @@ var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 //#endregion
 //#region package.json
-var version = "0.15.4";
+var version = "0.17.0";
 
 //#endregion
 //#region src/lib/interactive-mode.ts
@@ -1663,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
@@ -4388,56 +4392,178 @@ const sha256Namespaced = (contentType, contentSha256Hex) => {
 	return toBase64Url(createHash("sha256").update(input).digest());
 };
 
+//#endregion
+//#region src/lib/pty-runner.ts
+const ptyDimensions = () => {
+	const stdout = process$1.stdout;
+	return {
+		cols: typeof stdout.columns === "number" && stdout.columns > 0 ? stdout.columns : 120,
+		rows: typeof stdout.rows === "number" && stdout.rows > 0 ? stdout.rows : 40
+	};
+};
+const mergeEnv$1 = (overrides) => {
+	const merged = {};
+	for (const [key, value] of Object.entries(process$1.env)) if (typeof value === "string") merged[key] = value;
+	for (const [key, value] of Object.entries(overrides)) merged[key] = value;
+	return merged;
+};
+const trySpawn = (input) => {
+	const { cols, rows } = ptyDimensions();
+	try {
+		return spawn$1(input.command, [...input.args], {
+			name: "xterm-256color",
+			cols,
+			rows,
+			cwd: input.cwd,
+			env: mergeEnv$1(input.env)
+		});
+	} catch (error) {
+		return error instanceof Error ? error : new Error(String(error));
+	}
+};
+/**
+* Run a command in a pseudo-terminal so the subprocess sees a real TTY
+* (preserves spinners, progress bars, and ANSI colors emitted by tools like
+* CocoaPods and `expo prebuild`). Subprocess output is tee'd: forwarded to
+* `process.stdout` as raw bytes (so colors/positioning are preserved), and
+* also buffered into lines for the optional `onLine` callback.
+*
+* Returns the subprocess exit code. Spawn failures and signal exits surface
+* as non-zero exit codes (128+signal for Unix-style signal exits).
+*/
+const runInPty = (input) => Effect.async((resume) => {
+	const spawned = trySpawn(input);
+	if (spawned instanceof Error) {
+		process$1.stderr.write(`Failed to spawn "${input.command}" in pty: ${spawned.message}\n`);
+		resume(Effect.succeed(1));
+		return;
+	}
+	const proc = spawned;
+	let lineBuf = "";
+	const handleLine = (line) => {
+		if (input.onLine === void 0) return;
+		const annotation = input.onLine(line);
+		if (annotation !== void 0) process$1.stdout.write(`${annotation}\n`);
+	};
+	proc.onData((chunk) => {
+		if (input.silent !== true) process$1.stdout.write(chunk);
+		if (input.onLine === void 0) return;
+		lineBuf += chunk;
+		let nl = lineBuf.indexOf("\n");
+		while (nl !== -1) {
+			const line = lineBuf.slice(0, nl).replace(/\r$/u, "");
+			lineBuf = lineBuf.slice(nl + 1);
+			handleLine(line);
+			nl = lineBuf.indexOf("\n");
+		}
+	});
+	const handleResize = () => {
+		const { cols, rows } = ptyDimensions();
+		try {
+			proc.resize(cols, rows);
+		} catch {}
+	};
+	process$1.stdout.on("resize", handleResize);
+	proc.onExit(({ exitCode, signal }) => {
+		process$1.stdout.off("resize", handleResize);
+		if (lineBuf.length > 0) {
+			handleLine(lineBuf.replace(/\r$/u, ""));
+			lineBuf = "";
+		}
+		const code = signal !== void 0 && signal !== 0 ? 128 + signal : exitCode;
+		resume(Effect.succeed(code));
+	});
+	return Effect.sync(() => {
+		try {
+			proc.kill();
+		} catch {}
+		process$1.stdout.off("resize", handleResize);
+	});
+});
+
+//#endregion
+//#region src/lib/warning-style.ts
+const ANSI_REGEX_GLOBAL = /[›][[()#;?]*(?:\d{1,4}(?:;\d{0,4})*)?[\dA-ORZcf-ntqry=><]/gu;
+const stripAnsi = (input) => input.replaceAll(ANSI_REGEX_GLOBAL, "");
+const hasAnsi = (input) => {
+	ANSI_REGEX_GLOBAL.lastIndex = 0;
+	return ANSI_REGEX_GLOBAL.test(input);
+};
+const WARNING_PATTERNS = [
+	/^\s*warning:/iu,
+	/^\s*\[!\]/u,
+	/^\s*WARNING:/u,
+	/^\s*WARN\b/u,
+	/\bis deprecated\b/iu,
+	/^\s*DEPRECATION\b/iu,
+	/\[MT\]/u,
+	/⚠/u
+];
+const isWarningLine = (rawLine) => {
+	const plain = stripAnsi(rawLine);
+	return WARNING_PATTERNS.some((pattern) => pattern.test(plain));
+};
+/**
+* Style a single output line as a warning. If the line already contains ANSI
+* escapes (the subprocess pre-colored it), only prepend our yellow ⚠ marker
+* so the original colors survive. Otherwise color the whole line yellow.
+*/
+const styleWarningLine = (line) => hasAnsi(line) ? `${chalk.yellow("⚠")} ${line}` : chalk.yellow(`⚠ ${line}`);
+/**
+* Emit a CLI-owned warning. Suppressed in JSON mode; in human mode writes a
+* yellow, ⚠-prefixed line to stderr so it stands out from regular info logs.
+*/
+const printWarn = (message) => Effect.gen(function* () {
+	if ((yield* OutputMode).json) return;
+	yield* Console.warn(chalk.yellow(`⚠ warning: ${message}`));
+});
+
 //#endregion
 //#region src/commands/build/run-step.ts
-const runStep = (cmd, step) => Command.exitCode(cmd.pipe(Command.stdout("inherit"), Command.stderr("inherit"))).pipe(Effect.mapError((cause) => new BuildFailedError({
-	step,
-	exitCode: 1,
-	message: `${step} failed to spawn: ${String(cause)}`
-})), Effect.flatMap((code) => code === 0 ? Effect.void : Effect.fail(new BuildFailedError({
+const buildFailed = (step, exitCode, message) => new BuildFailedError({
 	step,
-	exitCode: code,
-	message: `${step} exited with code ${code}`
-}))));
+	exitCode,
+	message
+});
+const annotateWarning = (line) => isWarningLine(line) ? styleWarningLine(line) : void 0;
 /**
-* Run a build step with stdout piped through a formatter (e.g., xcpretty).
-* stderr passes through to the terminal directly.
+* Run a build step in a PTY so the subprocess sees a real TTY (spinners,
+* progress bars, ANSI colors are preserved). Completed lines are inspected
+* and any detected warning is re-echoed with our yellow ⚠ annotation.
+*/
+const runStep = (cmd, step) => runInPty({
+	command: cmd.command,
+	args: cmd.args,
+	cwd: cmd.cwd,
+	env: cmd.env,
+	onLine: annotateWarning
+}).pipe(Effect.flatMap((code) => code === 0 ? Effect.void : Effect.fail(buildFailed(step, code, `${step} exited with code ${code}`))));
+/**
+* Run a build step in a PTY, but feed each completed line through the supplied
+* xcpretty-style formatter before writing. Warning detection still applies to
+* the formatter's output so xcodebuild deprecation notices stand out.
+*
+* The PTY guarantees xcodebuild sees a real TTY (so it keeps colored output);
+* the formatter strips noise. On failure the formatter's build summary is
+* flushed to stderr to help diagnose.
 */
 const runStepFormatted = (cmd, step, formatter) => Effect.gen(function* () {
-	const proc = yield* Command.start(cmd.pipe(Command.stdout("pipe"), Command.stderr("pipe"))).pipe(Effect.mapError((cause) => new BuildFailedError({
-		step,
-		exitCode: 1,
-		message: `${step} failed to spawn: ${String(cause)}`
-	})));
-	const stdoutFiber = yield* proc.stdout.pipe(Stream.decodeText(), Stream.splitLines, Stream.runForEach((line) => {
-		const formatted = formatter.pipe(line);
-		return formatted.length > 0 ? Effect.sync(() => {
-			for (const output of formatted) process$1.stdout.write(`${output}\n`);
-		}) : Effect.void;
-	}), Effect.mapError((cause) => new BuildFailedError({
-		step,
-		exitCode: 1,
-		message: `${step} stdout stream error: ${String(cause)}`
-	})), Effect.fork);
-	const stderrFiber = yield* proc.stderr.pipe(Stream.decodeText(), Stream.splitLines, Stream.runForEach((line) => Effect.sync(() => process$1.stderr.write(`${line}\n`))), Effect.mapError((cause) => new BuildFailedError({
-		step,
-		exitCode: 1,
-		message: `${step} stderr stream error: ${String(cause)}`
-	})), Effect.fork);
-	yield* Effect.all([Fiber.join(stdoutFiber), Fiber.join(stderrFiber)], { concurrency: 2 }).pipe(Effect.catchAll(() => Effect.void));
-	const code = yield* proc.exitCode.pipe(Effect.mapError((cause) => new BuildFailedError({
-		step,
-		exitCode: 1,
-		message: `${step} exit code error: ${String(cause)}`
-	})));
+	const code = yield* runInPty({
+		command: cmd.command,
+		args: cmd.args,
+		cwd: cmd.cwd,
+		env: cmd.env,
+		silent: true,
+		onLine: (line) => {
+			const formatted = formatter.pipe(line);
+			for (const output of formatted) if (isWarningLine(output)) process$1.stdout.write(`${styleWarningLine(output)}\n`);
+			else process$1.stdout.write(`${output}\n`);
+		}
+	});
 	if (code !== 0) {
 		const summary = formatter.getBuildSummary();
-		if (summary) process$1.stderr.write(`${summary}\n`);
-		return yield* new BuildFailedError({
-			step,
-			exitCode: code,
-			message: `${step} exited with code ${code}`
-		});
+		if (summary.length > 0) process$1.stderr.write(`${summary}\n`);
+		return yield* Effect.fail(buildFailed(step, code, `${step} exited with code ${code}`));
 	}
 });
 
@@ -4470,7 +4596,18 @@ const runAndroidBuild = (input) => Effect.gen(function* () {
 		applicationIdentifier,
 		tempDir
 	});
-	yield* runStep(Command.make("bunx", "expo", "prebuild", "--platform", "android", "--clean").pipe(Command.workingDirectory(projectRoot), Command.env(commandEnv)), "expo prebuild android");
+	yield* runStep({
+		command: "bunx",
+		args: [
+			"expo",
+			"prebuild",
+			"--platform",
+			"android",
+			"--clean"
+		],
+		cwd: projectRoot,
+		env: commandEnv
+	}, "expo prebuild android");
 	const fs = yield* FileSystem.FileSystem;
 	const signingGradlePath = path.join(tempDir, "signing.gradle");
 	yield* fs.writeFileString(signingGradlePath, renderSigningGradle({
@@ -4479,8 +4616,16 @@ const runAndroidBuild = (input) => Effect.gen(function* () {
 		keyAlias: credentials.keyAlias,
 		keyPassword: credentials.keyPassword
 	}));
-	const taskName = gradleTaskName(format, flavor, buildType);
-	yield* runStep(Command.make("./gradlew", "--init-script", signingGradlePath, `:app:${taskName}`).pipe(Command.workingDirectory(androidDir), Command.env(commandEnv)), "gradlew");
+	yield* runStep({
+		command: "./gradlew",
+		args: [
+			"--init-script",
+			signingGradlePath,
+			`:app:${gradleTaskName(format, flavor, buildType)}`
+		],
+		cwd: androidDir,
+		env: commandEnv
+	}, "gradlew");
 	const artifactPath = yield* findAndroidArtifact({
 		projectRoot,
 		format,
@@ -5333,8 +5478,8 @@ const validateIosBuild = (params) => Effect.gen(function* () {
 	const validatedBundleIds = new Set(perBundle.map((entry) => entry.bundleId).filter((id) => id !== void 0));
 	for (const expected of params.expectedTargets) if (!validatedBundleIds.has(expected.bundleId)) warnings.push(`Expected signed target "${expected.bundleId}" was not found in the archive.`);
 	if (warnings.length > 0) {
-		yield* Console.warn("Post-build validation warnings:");
-		for (const warning of warnings) yield* Console.warn(`  - ${warning}`);
+		yield* printWarn("Post-build validation warnings:");
+		for (const warning of warnings) yield* printWarn(`  - ${warning}`);
 	}
 	return {
 		passed: warnings.length === 0,
@@ -5491,8 +5636,24 @@ const findXcworkspace = (iosDir) => Effect.gen(function* () {
 	return workspace;
 });
 const prebuildAndPods = (params) => Effect.gen(function* () {
-	yield* runStep(Command.make("bunx", "expo", "prebuild", "--platform", "ios", "--clean").pipe(Command.workingDirectory(params.projectRoot), Command.env(params.commandEnv)), "expo prebuild ios");
-	yield* runStep(Command.make("pod", "install").pipe(Command.workingDirectory(params.iosDir), Command.env(params.commandEnv)), "pod install");
+	yield* runStep({
+		command: "bunx",
+		args: [
+			"expo",
+			"prebuild",
+			"--platform",
+			"ios",
+			"--clean"
+		],
+		cwd: params.projectRoot,
+		env: params.commandEnv
+	}, "expo prebuild ios");
+	yield* runStep({
+		command: "pod",
+		args: ["install"],
+		cwd: params.iosDir,
+		env: params.commandEnv
+	}, "pod install");
 });
 const findAppDirectory = (root) => Effect.gen(function* () {
 	const fs = yield* FileSystem.FileSystem;
@@ -5527,13 +5688,46 @@ const runIosSimulatorBuild = (input) => Effect.gen(function* () {
 	const scheme = iosProfile.scheme ?? workspaceFilename.replace(/\.xcworkspace$/u, "");
 	const configuration = iosProfile.buildConfiguration ?? "Release";
 	const derivedDataPath = path.join(tempDir, "derived-data");
-	const buildCmd = Command.make("xcodebuild", "-workspace", workspaceFilename, "-scheme", scheme, "-configuration", configuration, "-sdk", "iphonesimulator", "-destination", "generic/platform=iOS Simulator", "-derivedDataPath", derivedDataPath, "build", "CODE_SIGNING_ALLOWED=NO", "CODE_SIGNING_REQUIRED=NO", "CODE_SIGN_IDENTITY=").pipe(Command.workingDirectory(iosDir), Command.env(commandEnv));
+	const buildCmd = {
+		command: "xcodebuild",
+		args: [
+			"-workspace",
+			workspaceFilename,
+			"-scheme",
+			scheme,
+			"-configuration",
+			configuration,
+			"-sdk",
+			"iphonesimulator",
+			"-destination",
+			"generic/platform=iOS Simulator",
+			"-derivedDataPath",
+			derivedDataPath,
+			"build",
+			"CODE_SIGNING_ALLOWED=NO",
+			"CODE_SIGNING_REQUIRED=NO",
+			"CODE_SIGN_IDENTITY="
+		],
+		cwd: iosDir,
+		env: commandEnv
+	};
 	const formatter = input.rawOutput ? void 0 : createXcodebuildFormatter(projectRoot);
 	yield* formatter ? runStepFormatted(buildCmd, "xcodebuild build (simulator)", formatter) : runStep(buildCmd, "xcodebuild build (simulator)");
 	const appDir = yield* findAppDirectory(path.join(derivedDataPath, "Build", "Products", `${configuration}-iphonesimulator`));
 	const archiveName = `${path.basename(appDir, ".app")}-simulator.tar.gz`;
 	const archivePath = path.join(tempDir, archiveName);
-	yield* runStep(Command.make("tar", "-czf", archivePath, "-C", path.dirname(appDir), path.basename(appDir)).pipe(Command.env(commandEnv)), "tar simulator .app");
+	yield* runStep({
+		command: "tar",
+		args: [
+			"-czf",
+			archivePath,
+			"-C",
+			path.dirname(appDir),
+			path.basename(appDir)
+		],
+		cwd: projectRoot,
+		env: commandEnv
+	}, "tar simulator .app");
 	const { sha256, byteSize } = yield* sha256File(archivePath);
 	return {
 		artifactPath: archivePath,
@@ -5636,7 +5830,23 @@ const runIosDeviceBuild = (input) => Effect.gen(function* () {
 		}))
 	});
 	const archivePath = path.join(tempDir, "build.xcarchive");
-	const archiveCmd = Command.make("xcodebuild", "-workspace", workspaceFilename, "-scheme", scheme, "-configuration", configuration, "-archivePath", archivePath, "-allowProvisioningUpdates", "archive").pipe(Command.workingDirectory(iosDir), Command.env(commandEnv));
+	const archiveCmd = {
+		command: "xcodebuild",
+		args: [
+			"-workspace",
+			workspaceFilename,
+			"-scheme",
+			scheme,
+			"-configuration",
+			configuration,
+			"-archivePath",
+			archivePath,
+			"-allowProvisioningUpdates",
+			"archive"
+		],
+		cwd: iosDir,
+		env: commandEnv
+	};
 	const formatter = input.rawOutput ? void 0 : createXcodebuildFormatter(projectRoot);
 	yield* formatter ? runStepFormatted(archiveCmd, "xcodebuild archive", formatter) : runStep(archiveCmd, "xcodebuild archive");
 	const exportOptionsPath = path.join(tempDir, "ExportOptions.plist");
@@ -5656,7 +5866,21 @@ const runIosDeviceBuild = (input) => Effect.gen(function* () {
 		}))
 	}));
 	const exportPath = path.join(tempDir, "export");
-	const exportCmd = Command.make("xcodebuild", "-exportArchive", "-archivePath", archivePath, "-exportPath", exportPath, "-exportOptionsPlist", exportOptionsPath, "-allowProvisioningUpdates").pipe(Command.workingDirectory(iosDir), Command.env(commandEnv));
+	const exportCmd = {
+		command: "xcodebuild",
+		args: [
+			"-exportArchive",
+			"-archivePath",
+			archivePath,
+			"-exportPath",
+			exportPath,
+			"-exportOptionsPlist",
+			exportOptionsPath,
+			"-allowProvisioningUpdates"
+		],
+		cwd: iosDir,
+		env: commandEnv
+	};
 	yield* formatter ? runStepFormatted(exportCmd, "xcodebuild exportArchive", formatter) : runStep(exportCmd, "xcodebuild exportArchive");
 	yield* validateIosBuild({
 		archivePath,
@@ -6241,7 +6465,7 @@ const readGradleConfig = (androidDir) => Effect.gen(function* () {
 const warnOnGradleMismatch = (gradleConfig, expectedPackage) => {
 	if (!gradleConfig?.applicationId) return Effect.void;
 	if (gradleConfig.applicationId === expectedPackage) return Effect.void;
-	return Console.warn(`Gradle applicationId "${gradleConfig.applicationId}" differs from app.json package "${expectedPackage}". The Gradle value will be used in the built APK/AAB.`);
+	return printWarn(`Gradle applicationId "${gradleConfig.applicationId}" differs from app.json package "${expectedPackage}". The Gradle value will be used in the built APK/AAB.`);
 };
 /**
 * Strip Groovy single-line and block comments.
@@ -6298,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;
@@ -6447,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,
@@ -6485,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)}` })));
@@ -6509,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 },
@@ -6653,7 +7007,8 @@ const BUILD_EXIT_EXTRAS = {
 	PresignedUrlExpiredError: 7,
 	CompleteError: 7,
 	EnvExportError: 7,
-	DirtyRepoError: 3
+	DirtyRepoError: 3,
+	StagingError: 6
 };
 const buildCommand = defineCommand({
 	meta: {