@hot-updater/cli-tools 0.35.8 → 0.35.10

package/dist/index.d.mts

@@ -296,6 +296,20 @@ declare const createHotUpdaterConfigScaffoldFromBuilder: (builder: ConfigBuilder
 }?: CreateHotUpdaterConfigScaffoldFromBuilderOptions) => HotUpdaterConfigScaffold;
 declare const writeHotUpdaterConfig: (scaffold: HotUpdaterConfigScaffold, filePath?: string) => Promise<WriteHotUpdaterConfigResult>;
 //#endregion
+//#region src/hotUpdaterEnv.d.ts
+type HotUpdaterInitEnv = {
+  readonly env: Readonly<Record<string, string>>;
+  readonly inputEnv?: Readonly<Record<string, string>>;
+  readonly managedEnv: Readonly<Record<string, string>>;
+};
+declare const getHotUpdaterInitInputEnv: ({
+  env,
+  managedEnv
+}: HotUpdaterInitEnv, nonInteractive: boolean) => Readonly<Record<string, string>>;
+declare const readHotUpdaterInitEnv: (cwd: string, envFile?: string) => Promise<HotUpdaterInitEnv>;
+declare const readHotUpdaterEnv: (cwd: string) => Promise<Readonly<Record<string, string>>>;
+declare const getHotUpdaterEnvValue: (env: Readonly<Record<string, string>>, key: string) => string | undefined;
+//#endregion
 //#region src/HotUpdateDirUtil.d.ts
 declare const HotUpdateDirUtil: {
   readonly dirName: ".hot-updater";
@@ -320,6 +334,113 @@ declare const HotUpdateDirUtil: {
   }) => string;
 };
 //#endregion
+//#region src/initProvider.d.ts
+type InitProviderInputPersistence = "always" | "with-consent";
+type InitProviderInputDefinition = {
+  readonly envKey: string;
+  readonly help: string;
+  readonly optional?: boolean;
+  readonly persistence?: InitProviderInputPersistence;
+  readonly preflight?: boolean;
+  readonly prompt?: {
+    readonly defaultValue?: string;
+    readonly message: string;
+    readonly placeholder?: string;
+    readonly type: "confirm" | "password" | "select" | "text";
+  };
+  readonly requiredWhen?: (inputs: Readonly<Record<string, string | undefined>>) => boolean;
+  readonly requirementHint?: string;
+  readonly validate?: (value: string | undefined) => boolean;
+};
+type InitProviderTextPromptDefinition = {
+  readonly defaultValue?: string;
+  readonly message: string;
+  readonly placeholder?: string;
+  readonly type: "text";
+};
+type InitProviderInputsDefinition = Readonly<Record<string, InitProviderInputDefinition>>;
+type InitProviderDefinition<TInputs extends InitProviderInputsDefinition = InitProviderInputsDefinition> = {
+  readonly inputs: TInputs;
+  readonly label: string;
+};
+declare const defineInitProvider: <const TInputs extends InitProviderInputsDefinition>(provider: InitProviderDefinition<TInputs>) => InitProviderDefinition<TInputs>;
+declare const shouldAutoSelectOnlyInitResource: ({
+  availableResourceCount,
+  savedIdentifier
+}: {
+  readonly availableResourceCount: number;
+  readonly savedIdentifier?: string;
+}) => boolean;
+declare const getInitProviderTextPromptValues: (prompt: InitProviderTextPromptDefinition, savedValue?: string) => {
+  initialValue: string | undefined;
+  placeholder: string | undefined;
+};
+declare const resolveInitProviderInput: (env: Readonly<Record<string, string>>, input: InitProviderInputDefinition) => string | undefined;
+declare const resolveInitProviderInputs: (env: Readonly<Record<string, string>>, provider: InitProviderDefinition) => Readonly<Record<string, string | undefined>>;
+declare const getMissingInitProviderInputs: ({
+  inputs,
+  preflightOnly,
+  provider
+}: {
+  readonly inputs: Readonly<Record<string, string | undefined>>;
+  readonly preflightOnly?: boolean;
+  readonly provider: InitProviderDefinition;
+}) => readonly string[];
+declare const assertInitProviderInputs: <TInputs extends InitProviderInputsDefinition>({
+  inputs,
+  provider,
+  strict
+}: {
+  readonly inputs: Readonly<Record<string, string | undefined>>;
+  readonly provider: InitProviderDefinition<TInputs>;
+  readonly strict?: boolean;
+}) => void;
+declare const confirmInitInputPersistence: <TInputs extends InitProviderInputsDefinition>({
+  existingEnv,
+  inputs,
+  nonInteractive,
+  provider
+}: {
+  readonly existingEnv: Readonly<Record<string, string>>;
+  readonly inputs: Readonly<Record<string, string | undefined>>;
+  readonly nonInteractive: boolean;
+  readonly provider: InitProviderDefinition<TInputs>;
+}) => Promise<boolean>;
+declare const getInitProviderEnvVars: <TInputs extends InitProviderInputsDefinition>({
+  includeConsentInputs,
+  inputs,
+  provider
+}: {
+  readonly includeConsentInputs: boolean;
+  readonly inputs: Readonly<Record<string, string | undefined>>;
+  readonly provider: InitProviderDefinition<TInputs>;
+}) => Record<string, string>;
+//#endregion
+//#region src/initOptions.d.ts
+type RunInitOptions = {
+  readonly build: BuildType;
+  readonly envFile?: string;
+};
+declare class InitError extends Error {
+  readonly name: string;
+}
+declare class MissingInitInputsError extends InitError {
+  readonly missingInputs: readonly string[];
+  readonly name = "MissingInitInputsError";
+  constructor(missingInputs: readonly string[]);
+}
+declare class InitEnvFileError extends InitError {
+  readonly name = "InitEnvFileError";
+}
+declare const assertInitInputs: ({
+  inputs,
+  strict
+}: {
+  readonly inputs: Readonly<Record<string, string | undefined>>;
+  readonly strict?: boolean;
+}) => void;
+declare const getMissingInitInputs: (inputs: Readonly<Record<string, string | undefined>>) => readonly string[];
+//#endregion
 //#region src/LogWriter.d.ts
 type HotUpdaterLogWriter = {
   logFilePath: string | null;
@@ -360,7 +481,8 @@ type EnvVarValue = string | {
   value: string;
 };
 declare const makeEnv: (newEnvVars: Record<string, EnvVarValue>, filePath?: string, options?: {
-  preserveKeys?: string[];
+  readonly preserveKeys?: readonly string[];
+  readonly removeKeys?: readonly string[];
 }) => Promise<string>;
 //#endregion
 //#region src/promoteBundle.d.ts
@@ -1687,4 +1809,4 @@ type TransformTemplateArgs<T extends string> = { [Key in ExtractPlaceholders<T>]
  */
 declare function transformTemplate<T extends string>(templateString: T, values: TransformTemplateArgs<T>): string;
 //#endregion
-export { BuildLogger, BuildLoggerConfig, BuildType, ConfigBuilder, ConfigBuilderScaffold, ConfigResponse, CreateHotUpdaterConfigScaffoldFromBuilderOptions, CreateHotUpdaterConfigScaffoldOptions, HOT_UPDATER_SERVER_PACKAGE_VERSION_ENV, HotUpdateDirUtil, HotUpdaterConfigOptions, HotUpdaterConfigScaffold, HotUpdaterLogWriter, IConfigBuilder, ImportInfo, LEGACY_BUNDLE_ERROR, ManagedHelperStatement, ManagedHelperStrategy, PromoteBundleDependencies, PromoteBundleInput, PromptProgress, PromptSpinner, ProviderConfig, ReactNativeMetadata, ReadPackageUpResult, WriteHotUpdaterConfigResult, banner, typedColors as colors, copyDirToTmp, createCopiedBundleArchive, createHotUpdaterConfigScaffold, createHotUpdaterConfigScaffoldFromBuilder, createLogWriter, createTarBr, createTarBrTargetFiles, createTarGz, createTarGzTargetFiles, createZip, createZipTargetFiles, decryptJson, encryptJson, ensureInstallPackages, getAndroidSdkPath, getCwd, getPackageManager, getReactNativeMetadatas, link, loadConfig, log, makeEnv, p, printBanner, promoteBundle, readPackageUp, renderImportStatements, resolveHotUpdaterServerVersion, resolvePackageVersion, stripAnsi, transformEnv, transformTemplate, writeHotUpdaterConfig };
+export { BuildLogger, BuildLoggerConfig, BuildType, ConfigBuilder, ConfigBuilderScaffold, ConfigResponse, CreateHotUpdaterConfigScaffoldFromBuilderOptions, CreateHotUpdaterConfigScaffoldOptions, HOT_UPDATER_SERVER_PACKAGE_VERSION_ENV, HotUpdateDirUtil, HotUpdaterConfigOptions, HotUpdaterConfigScaffold, HotUpdaterInitEnv, HotUpdaterLogWriter, IConfigBuilder, ImportInfo, InitEnvFileError, InitError, InitProviderDefinition, InitProviderInputDefinition, InitProviderInputPersistence, LEGACY_BUNDLE_ERROR, ManagedHelperStatement, ManagedHelperStrategy, MissingInitInputsError, PromoteBundleDependencies, PromoteBundleInput, PromptProgress, PromptSpinner, ProviderConfig, ReactNativeMetadata, ReadPackageUpResult, RunInitOptions, WriteHotUpdaterConfigResult, assertInitInputs, assertInitProviderInputs, banner, typedColors as colors, confirmInitInputPersistence, copyDirToTmp, createCopiedBundleArchive, createHotUpdaterConfigScaffold, createHotUpdaterConfigScaffoldFromBuilder, createLogWriter, createTarBr, createTarBrTargetFiles, createTarGz, createTarGzTargetFiles, createZip, createZipTargetFiles, decryptJson, defineInitProvider, encryptJson, ensureInstallPackages, getAndroidSdkPath, getCwd, getHotUpdaterEnvValue, getHotUpdaterInitInputEnv, getInitProviderEnvVars, getInitProviderTextPromptValues, getMissingInitInputs, getMissingInitProviderInputs, getPackageManager, getReactNativeMetadatas, link, loadConfig, log, makeEnv, p, printBanner, promoteBundle, readHotUpdaterEnv, readHotUpdaterInitEnv, readPackageUp, renderImportStatements, resolveHotUpdaterServerVersion, resolveInitProviderInput, resolveInitProviderInputs, resolvePackageVersion, shouldAutoSelectOnlyInitResource, stripAnsi, transformEnv, transformTemplate, writeHotUpdaterConfig };

package/dist/index.mjs

@@ -24,7 +24,7 @@ import { EventEmitter as EventEmitter$1, addAbortListener, on, once, setMaxListe
 import As, { Duplex, PassThrough as PassThrough$1, Readable as Readable$1, Transform, Writable, getDefaultHighWaterMark } from "node:stream";
 import { StringDecoder } from "node:string_decoder";
 import no from "node:assert";
-import crypto$1, { randomBytes } from "node:crypto";
+import crypto$1, { randomBytes, randomUUID } from "node:crypto";
 import fs$3 from "node:fs/promises";
 import { fileURLToPath } from "node:url";
 import { ChildProcess, execFile, spawn, spawnSync } from "node:child_process";
@@ -32,7 +32,7 @@ import { scheduler, setImmediate as setImmediate$1, setTimeout as setTimeout$1 }
 import { serialize } from "node:v8";
 import { finished, pipeline as pipeline$1 } from "node:stream/promises";
 import { Buffer as Buffer$2 } from "node:buffer";
-import ts from "typescript";
+import { parseSync } from "oxc-parser";
 import { loadConfig as loadConfig$1 } from "unconfig";
 import { brotliDecompressSync, createBrotliCompress as createBrotliCompress$1 } from "node:zlib";
 import { getManifestFileHash, stripBundleArtifactMetadata } from "@hot-updater/core";
@@ -22329,8 +22329,13 @@ const tasks = async (taskList, options) => {
 		if (task.enabled === false) continue;
 		const taskSpinner = spinner(options);
 		taskSpinner.start(task.title);
-		const result = await task.task(taskSpinner.message);
-		taskSpinner.stop(result || task.title);
+		try {
+			const result = await task.task(taskSpinner.message);
+			taskSpinner.stop(result || task.title);
+		} catch (error) {
+			taskSpinner.error(error instanceof Error ? error.message : String(error));
+			throw error;
+		}
 	}
 };
 const p = {
@@ -26143,7 +26148,7 @@ var ti = [
 	"?",
 	":"
 ], Qi = ti.map((s) => String.fromCodePoint(61440 + Number(s.codePointAt(0)))), vn = new Map(ti.map((s, t) => [s, Qi[t]])), Mn = new Map(Qi.map((s, t) => [s, ti[t]])), Ji = (s) => ti.reduce((t, e) => t.split(e).join(vn.get(e)), s), $s = (s) => Qi.reduce((t, e) => t.split(e).join(Mn.get(e)), s);
-var er = (s, t) => t ? (s = f(s).replace(/^\.(\/|$)/, ""), mt(t) + "/" + s) : f(s), Bn = 16 * 1024 * 1024, Qs = Symbol("process"), Js = Symbol("file"), js = Symbol("directory"), ts$1 = Symbol("symlink"), tr = Symbol("hardlink"), ce = Symbol("header"), ei = Symbol("read"), es = Symbol("lstat"), ii = Symbol("onlstat"), is = Symbol("onread"), ss = Symbol("onreadlink"), rs = Symbol("openfile"), ns = Symbol("onopenfile"), pt = Symbol("close"), si = Symbol("mode"), os$1 = Symbol("awaitDrain"), ji = Symbol("ondrain"), X = Symbol("prefix"), fe = class extends A {
+var er = (s, t) => t ? (s = f(s).replace(/^\.(\/|$)/, ""), mt(t) + "/" + s) : f(s), Bn = 16 * 1024 * 1024, Qs = Symbol("process"), Js = Symbol("file"), js = Symbol("directory"), ts = Symbol("symlink"), tr = Symbol("hardlink"), ce = Symbol("header"), ei = Symbol("read"), es = Symbol("lstat"), ii = Symbol("onlstat"), is = Symbol("onread"), ss = Symbol("onreadlink"), rs = Symbol("openfile"), ns = Symbol("onopenfile"), pt = Symbol("close"), si = Symbol("mode"), os$1 = Symbol("awaitDrain"), ji = Symbol("ondrain"), X = Symbol("prefix"), fe = class extends A {
 	path;
 	portable;
 	myuid = process.getuid && process.getuid() || 0;
@@ -26208,7 +26213,7 @@ var er = (s, t) => t ? (s = f(s).replace(/^\.(\/|$)/, ""), mt(t) + "/" + s) : f(
 		switch (this.type) {
 			case "File": return this[Js]();
 			case "Directory": return this[js]();
-			case "SymbolicLink": return this[ts$1]();
+			case "SymbolicLink": return this[ts]();
 			default: return this.end();
 		}
 	}
@@ -26254,7 +26259,7 @@ var er = (s, t) => t ? (s = f(s).replace(/^\.(\/|$)/, ""), mt(t) + "/" + s) : f(
 		if (!this.stat) throw new Error("cannot create directory entry without stat");
 		this.path.slice(-1) !== "/" && (this.path += "/"), this.stat.size = 0, this[ce](), this.end();
 	}
-	[ts$1]() {
+	[ts]() {
 		fs.readlink(this.absolute, (t, e) => {
 			if (t) return this.emit("error", t);
 			this[ss](e);
@@ -26343,7 +26348,7 @@ var er = (s, t) => t ? (s = f(s).replace(/^\.(\/|$)/, ""), mt(t) + "/" + s) : f(
 	[es]() {
 		this[ii](fs.lstatSync(this.absolute));
 	}
-	[ts$1]() {
+	[ts]() {
 		this[ss](fs.readlinkSync(this.absolute));
 	}
 	[rs]() {
@@ -42796,11 +42801,12 @@ const readPackageUp = async (cwd) => {
 const ensureInstallPackages = async (packages, options) => {
 	const { versionResolver = (pkg) => pkg } = options ?? {};
 	const pkgJson = await readPackageUp(getCwd());
+	const installedPackages = new Set([...Object.keys(pkgJson?.packageJson?.dependencies ?? {}), ...Object.keys(pkgJson?.packageJson?.devDependencies ?? {})]);
 	const dependenciesToInstall = (packages.dependencies ?? []).filter((pkg) => {
-		return !pkgJson?.packageJson?.dependencies?.[pkg];
+		return !installedPackages.has(pkg);
 	});
 	const devDependenciesToInstall = (packages.devDependencies ?? []).filter((pkg) => {
-		return !pkgJson?.packageJson?.devDependencies?.[pkg];
+		return !installedPackages.has(pkg);
 	});
 	const packageManager = getPackageManager();
 	await p.tasks([{
@@ -43235,8 +43241,7 @@ const getReactNativeMetadatas = (cwd) => {
 //#endregion
 //#region src/hotUpdaterConfig.ts
 const HOT_UPDATER_CONFIG_PATH = "hot-updater.config.ts";
-const WRAP_PREFIX = "const __hotUpdaterValue = ";
-const WRAP_SUFFIX = ";";
+const CONFIG_FILE_NAME = "hot-updater.config.ts";
 const MANAGED_IMPORT_PACKAGES = new Set([
 	"dotenv",
 	"firebase-admin",
@@ -43256,52 +43261,70 @@ const KNOWN_BUILD_CALLEES = new Set([
 	"expo",
 	"rock"
 ]);
-const createSnippetSourceFile = (code) => ts.createSourceFile("hot-updater-config-snippet.ts", code, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
-const extractCallIdentifier = (initializer) => {
-	const match = /^\s*([A-Za-z_$][\w$]*)\s*\(/.exec(initializer);
-	if (!match) throw new Error(`Failed to extract call identifier from "${initializer}"`);
-	return match[1];
-};
-const wrapExpression = (expression) => `${WRAP_PREFIX}${expression}${WRAP_SUFFIX}`;
-const getWrappedObjectLiteral = (text) => {
-	const sourceFile = createSnippetSourceFile(wrapExpression(text));
-	const statement = sourceFile.statements[0];
-	if (!statement || !ts.isVariableStatement(statement)) return null;
-	const declaration = statement.declarationList.declarations[0];
-	if (!declaration || !declaration.initializer) return null;
-	if (!ts.isObjectLiteralExpression(declaration.initializer)) return null;
+const parseConfigSource = (text) => {
+	const result = parseSync(CONFIG_FILE_NAME, text, {
+		astType: "js",
+		lang: "ts",
+		preserveParens: false,
+		sourceType: "module",
+		showSemanticErrors: false
+	});
+	if (result.errors.length > 0) return null;
 	return {
-		sourceFile,
-		objectLiteral: declaration.initializer,
-		offset: 26
-	};
-};
-const parseVariableStatement = (code) => {
-	const sourceFile = createSnippetSourceFile(code);
-	const statement = sourceFile.statements.find((node) => ts.isVariableStatement(node));
-	if (!statement || !ts.isVariableStatement(statement)) return null;
-	const declaration = statement.declarationList.declarations[0];
-	if (!declaration || !ts.isIdentifier(declaration.name) || !declaration.initializer) return null;
+		program: result.program,
+		text
+	};
+};
+const getNodeText = (source, node) => source.text.slice(node.start, node.end);
+const getTopLevelFullStart = (source, statement) => {
+	const statementIndex = source.program.body.findIndex((candidate) => candidate === statement);
+	if (statementIndex <= 0) return statementIndex === 0 ? 0 : statement.start;
+	return source.program.body[statementIndex - 1]?.end ?? statement.start;
+};
+const getStatementText = (source, statement) => source.text.slice(getTopLevelFullStart(source, statement), statement.end).trim();
+const parseVariableStatement = (text) => {
+	const source = parseConfigSource(text);
+	if (!source) return null;
+	const statement = source.program.body.find((candidate) => candidate.type === "VariableDeclaration");
+	if (statement?.type !== "VariableDeclaration") return null;
+	const declaration = statement.declarations[0];
+	if (declaration?.id.type !== "Identifier" || !declaration.init) return null;
 	return {
-		sourceFile,
+		source,
 		statement,
 		declaration
 	};
 };
-const getPropertyName = (property) => {
-	if (ts.isIdentifier(property) || ts.isStringLiteral(property) || ts.isNumericLiteral(property)) return property.text;
-	if (ts.isSpreadAssignment(property)) return null;
-	if (ts.isShorthandPropertyAssignment(property)) return property.name.text;
-	if (ts.isPropertyAssignment(property) || ts.isMethodDeclaration(property) || ts.isGetAccessorDeclaration(property) || ts.isSetAccessorDeclaration(property)) {
-		const { name } = property;
-		if (ts.isIdentifier(name) || ts.isStringLiteral(name)) return name.text;
-		if (ts.isNumericLiteral(name)) return name.text;
-	}
+const getConfigObjectExpression = (argument) => {
+	const expression = argument?.type === "TSSatisfiesExpression" ? argument.expression : argument;
+	return expression?.type === "ObjectExpression" ? expression : null;
+};
+const findDefineConfigObject = (source) => {
+	const exportDeclaration = source.program.body.find((statement) => {
+		if (statement.type !== "ExportDefaultDeclaration") return false;
+		const declaration = statement.declaration;
+		if (declaration.type !== "CallExpression" || declaration.callee.type !== "Identifier") return false;
+		return declaration.callee.name === "defineConfig" && getConfigObjectExpression(declaration.arguments[0]) !== null;
+	});
+	if (exportDeclaration?.type !== "ExportDefaultDeclaration") return null;
+	const declaration = exportDeclaration.declaration;
+	if (declaration.type !== "CallExpression") return null;
+	const objectExpression = getConfigObjectExpression(declaration.arguments[0]);
+	if (!objectExpression) return null;
+	return {
+		exportDeclaration,
+		objectExpression
+	};
+};
+const getObjectPropertyName = (property) => {
+	if (property.type === "SpreadElement" || property.computed) return null;
+	const { key } = property;
+	if (key.type === "Identifier") return key.name;
+	if (key.type === "Literal" && (typeof key.value === "string" || typeof key.value === "number")) return String(key.value);
 	return null;
 };
-const trimStatementText = (text) => text.trim();
-const getStatementText = (sourceText, statement) => trimStatementText(sourceText.slice(statement.getFullStart(), statement.end));
-const getObjectTrailingComma = (text) => {
+const isDataProperty = (property) => property.type === "Property" && property.kind === "init" && !property.method && !property.shorthand;
+const hasTrailingComma = (text) => {
 	const closeBraceIndex = text.lastIndexOf("}");
 	if (closeBraceIndex === -1) return false;
 	let index = closeBraceIndex - 1;
@@ -43310,7 +43333,7 @@ const getObjectTrailingComma = (text) => {
 };
 const dedentBlock = (text) => {
 	const lines = text.replace(/\s+$/, "").split("\n");
-	const indents = lines.filter((line) => line.trim() !== "").map((line) => line.match(/^\s*/)[0].length);
+	const indents = lines.filter((line) => line.trim() !== "").map((line) => line.match(/^\s*/)?.[0].length ?? 0);
 	const minIndent = indents.length > 0 ? Math.min(...indents) : 0;
 	return lines.map((line) => line.slice(minIndent)).join("\n");
 };
@@ -43322,88 +43345,73 @@ const appendMissingProperties = (objectText, propertyTexts, hasExistingPropertie
 	const formattedProperties = propertyTexts.map((propertyText) => indentBlock(propertyText, childIndent)).join(",\n");
 	const closeBraceIndex = objectText.lastIndexOf("}");
 	if (closeBraceIndex === -1) return objectText;
-	const prefix = hasExistingProperties ? getObjectTrailingComma(objectText) ? "\n" : ",\n" : "\n";
+	const prefix = hasExistingProperties ? hasTrailingComma(objectText) ? "\n" : ",\n" : "\n";
 	const suffix = `,\n${closingIndent}`;
 	return `${objectText.slice(0, closeBraceIndex)}${prefix}${formattedProperties}${suffix}${objectText.slice(closeBraceIndex)}`;
 };
-const mergeObjectLiteralText = (existingText, newText) => {
-	const existingWrapped = getWrappedObjectLiteral(existingText);
-	const newWrapped = getWrappedObjectLiteral(newText);
-	if (!existingWrapped || !newWrapped) return null;
+const mergeObjectLiteralText = (existingObject, newObject) => {
+	const existingText = getNodeText(existingObject.source, existingObject.objectExpression);
 	const existingPropertyNames = /* @__PURE__ */ new Set();
 	const existingSpreadTexts = /* @__PURE__ */ new Set();
 	const edits = [];
-	for (const property of existingWrapped.objectLiteral.properties) {
-		if (ts.isSpreadAssignment(property)) {
-			existingSpreadTexts.add(property.expression.getText(existingWrapped.sourceFile).trim());
+	for (const property of existingObject.objectExpression.properties) {
+		if (property.type === "SpreadElement") {
+			existingSpreadTexts.add(getNodeText(existingObject.source, property.argument).trim());
 			continue;
 		}
-		const propertyName = getPropertyName(property);
+		const propertyName = getObjectPropertyName(property);
 		if (!propertyName) continue;
 		existingPropertyNames.add(propertyName);
-		const nextProperty = newWrapped.objectLiteral.properties.find((candidate) => {
-			if (ts.isSpreadAssignment(candidate)) return false;
-			return getPropertyName(candidate) === propertyName;
-		});
-		if (!nextProperty || !ts.isPropertyAssignment(property) || !ts.isPropertyAssignment(nextProperty)) continue;
-		if (ts.isObjectLiteralExpression(property.initializer) && ts.isObjectLiteralExpression(nextProperty.initializer)) {
-			const mergedInitializer = mergeObjectLiteralText(property.initializer.getText(existingWrapped.sourceFile), nextProperty.initializer.getText(newWrapped.sourceFile));
-			if (!mergedInitializer) return null;
+		const nextProperty = newObject.objectExpression.properties.find((candidate) => getObjectPropertyName(candidate) === propertyName);
+		if (!nextProperty || !isDataProperty(property) || !isDataProperty(nextProperty)) continue;
+		if (property.value.type === "ObjectExpression" && nextProperty.value.type === "ObjectExpression") {
+			const mergedValue = mergeObjectLiteralText({
+				objectExpression: property.value,
+				source: existingObject.source
+			}, {
+				objectExpression: nextProperty.value,
+				source: newObject.source
+			});
+			if (!mergedValue) return null;
 			edits.push({
-				start: property.initializer.getStart(existingWrapped.sourceFile) - existingWrapped.offset,
-				end: property.initializer.end - existingWrapped.offset,
-				text: mergedInitializer
+				start: property.value.start - existingObject.objectExpression.start,
+				end: property.value.end - existingObject.objectExpression.start,
+				text: mergedValue
 			});
 		}
 	}
 	let mergedText = existingText;
-	for (const edit of edits.sort((a, b) => b.start - a.start)) mergedText = mergedText.slice(0, edit.start) + edit.text + mergedText.slice(edit.end);
-	const missingPropertyTexts = newWrapped.objectLiteral.properties.filter((property) => {
-		if (ts.isSpreadAssignment(property)) return !existingSpreadTexts.has(property.expression.getText(newWrapped.sourceFile).trim());
-		const propertyName = getPropertyName(property);
+	for (const edit of edits.sort((left, right) => right.start - left.start)) mergedText = mergedText.slice(0, edit.start) + edit.text + mergedText.slice(edit.end);
+	const missingPropertyTexts = newObject.objectExpression.properties.filter((property) => {
+		if (property.type === "SpreadElement") return !existingSpreadTexts.has(getNodeText(newObject.source, property.argument).trim());
+		const propertyName = getObjectPropertyName(property);
 		return propertyName ? !existingPropertyNames.has(propertyName) : false;
-	}).map((property) => property.getText(newWrapped.sourceFile));
-	return appendMissingProperties(mergedText, missingPropertyTexts, existingWrapped.objectLiteral.properties.length > 0);
-};
-const buildMergedCallInitializer = (existingCall, existingSourceFile, newCall, newSourceFile) => {
-	const existingCallee = existingCall.expression.getText(existingSourceFile);
-	const [existingArg] = existingCall.arguments;
-	const [newArg] = newCall.arguments;
-	if (existingCall.arguments.length === 1 && newCall.arguments.length === 1 && existingArg && newArg && ts.isObjectLiteralExpression(existingArg) && ts.isObjectLiteralExpression(newArg)) {
-		const mergedObjectLiteral = mergeObjectLiteralText(existingArg.getText(existingSourceFile), newArg.getText(newSourceFile));
+	}).map((property) => getNodeText(newObject.source, property));
+	return appendMissingProperties(mergedText, missingPropertyTexts, existingObject.objectExpression.properties.length > 0);
+};
+const buildMergedCallInitializer = (existing, next) => {
+	const [existingArgument] = existing.callExpression.arguments;
+	const [nextArgument] = next.callExpression.arguments;
+	if (existing.callExpression.arguments.length === 1 && next.callExpression.arguments.length === 1 && existingArgument?.type === "ObjectExpression" && nextArgument?.type === "ObjectExpression") {
+		const mergedObjectLiteral = mergeObjectLiteralText({
+			objectExpression: existingArgument,
+			source: existing.source
+		}, {
+			objectExpression: nextArgument,
+			source: next.source
+		});
 		if (!mergedObjectLiteral) return null;
-		return `${existingCallee}(${mergedObjectLiteral})`;
+		return `${getNodeText(existing.source, existing.callExpression.callee)}(${mergedObjectLiteral})`;
 	}
-	return existingCall.getText(existingSourceFile);
+	return getNodeText(existing.source, existing.callExpression);
 };
-const findDefineConfigObject = (sourceFile) => {
-	const exportAssignment = sourceFile.statements.find((statement) => {
-		if (!ts.isExportAssignment(statement)) return false;
-		const expression = statement.expression;
-		if (!ts.isCallExpression(expression)) return false;
-		return ts.isIdentifier(expression.expression) && expression.expression.text === "defineConfig" && expression.arguments.length > 0 && ts.isObjectLiteralExpression(expression.arguments[0]);
-	});
-	if (!exportAssignment || !ts.isExportAssignment(exportAssignment)) return null;
-	const expression = exportAssignment.expression;
-	if (!ts.isCallExpression(expression)) return null;
-	const [argument] = expression.arguments;
-	if (!argument || !ts.isObjectLiteralExpression(argument)) return null;
-	return {
-		exportAssignment,
-		objectLiteral: argument
-	};
+const findManagedProperty = (objectExpression, propertyName) => {
+	const property = objectExpression.properties.find((candidate) => candidate.type === "Property" && candidate.kind === "init" && !candidate.method && !candidate.shorthand && getObjectPropertyName(candidate) === propertyName);
+	return property?.type === "Property" ? property : null;
 };
-const findManagedProperty = (objectLiteral, propertyName) => objectLiteral.properties.find((property) => ts.isPropertyAssignment(property) && getPropertyName(property.name) === propertyName);
 const getCallCallee = (expression) => {
-	if (!ts.isCallExpression(expression) || !ts.isIdentifier(expression.expression)) return null;
-	return expression.expression.text;
-};
-const isConfigCallStatement = (statement) => ts.isExpressionStatement(statement) && ts.isCallExpression(statement.expression) && ts.isIdentifier(statement.expression.expression) && statement.expression.expression.text === "config";
-const isManagedHelperStatement = (statement) => {
-	if (!ts.isVariableStatement(statement)) return null;
-	const declaration = statement.declarationList.declarations[0];
-	if (!declaration || !ts.isIdentifier(declaration.name)) return null;
-	return MANAGED_HELPER_NAMES.has(declaration.name.text) ? declaration.name.text : null;
+	if (expression.type !== "CallExpression" || expression.callee.type !== "Identifier") return null;
+	return expression.callee.name;
 };
 const mergeHelperStatement = (existingStatementText, helper) => {
 	if (helper.strategy === "preserve-existing") return existingStatementText;
@@ -43411,16 +43419,22 @@ const mergeHelperStatement = (existingStatementText, helper) => {
 	const existingStatement = parseVariableStatement(existingStatementText);
 	const nextStatement = parseVariableStatement(helper.code);
 	if (!existingStatement || !nextStatement) return null;
-	const existingInitializer = existingStatement.declaration.initializer;
-	const newInitializer = nextStatement.declaration.initializer;
-	if (!existingInitializer || !newInitializer || !ts.isObjectLiteralExpression(existingInitializer) || !ts.isObjectLiteralExpression(newInitializer)) return null;
-	const mergedInitializer = mergeObjectLiteralText(existingInitializer.getText(existingStatement.sourceFile), newInitializer.getText(nextStatement.sourceFile));
+	const existingInitializer = existingStatement.declaration.init;
+	const nextInitializer = nextStatement.declaration.init;
+	if (existingInitializer?.type !== "ObjectExpression" || nextInitializer?.type !== "ObjectExpression") return null;
+	const mergedInitializer = mergeObjectLiteralText({
+		objectExpression: existingInitializer,
+		source: existingStatement.source
+	}, {
+		objectExpression: nextInitializer,
+		source: nextStatement.source
+	});
 	if (!mergedInitializer) return null;
-	return `${ts.tokenToString(existingStatement.statement.declarationList.flags & ts.NodeFlags.Const ? ts.SyntaxKind.ConstKeyword : existingStatement.statement.declarationList.flags & ts.NodeFlags.Let ? ts.SyntaxKind.LetKeyword : ts.SyntaxKind.VarKeyword) ?? "const"} ${helper.name} = ${mergedInitializer};`;
+	return `${existingStatement.statement.kind === "let" || existingStatement.statement.kind === "var" ? existingStatement.statement.kind : "const"} ${helper.name} = ${mergedInitializer};`;
 };
-const updateManagedObject = (existingText, existingObject, newObject, existingSourceFile, newSourceFile) => {
-	const objectStart = existingObject.getStart(existingSourceFile);
-	const objectText = existingText.slice(objectStart, existingObject.end);
+const updateManagedObject = (existing, next) => {
+	const objectStart = existing.objectExpression.start;
+	const objectText = getNodeText(existing.source, existing.objectExpression);
 	const propertyEdits = [];
 	const missingPropertyTexts = [];
 	for (const propertyName of [
@@ -43428,85 +43442,133 @@ const updateManagedObject = (existingText, existingObject, newObject, existingSo
 		"storage",
 		"database"
 	]) {
-		const existingProperty = findManagedProperty(existingObject, propertyName);
-		const nextProperty = findManagedProperty(newObject, propertyName);
+		const existingProperty = findManagedProperty(existing.objectExpression, propertyName);
+		const nextProperty = findManagedProperty(next.objectExpression, propertyName);
 		if (!nextProperty) continue;
 		if (!existingProperty) {
-			missingPropertyTexts.push(nextProperty.getText(newSourceFile));
+			missingPropertyTexts.push(getNodeText(next.source, nextProperty));
 			continue;
 		}
-		if (!ts.isCallExpression(existingProperty.initializer)) return null;
-		if (!ts.isCallExpression(nextProperty.initializer)) return null;
-		const existingCallee = getCallCallee(existingProperty.initializer);
-		const nextCallee = getCallCallee(nextProperty.initializer);
+		const existingCallee = getCallCallee(existingProperty.value);
+		const nextCallee = getCallCallee(nextProperty.value);
 		if (!existingCallee || !nextCallee) return null;
-		let nextInitializerText = nextProperty.initializer.getText(newSourceFile);
+		let nextInitializerText = getNodeText(next.source, nextProperty.value);
 		if (propertyName === "build") {
 			if (existingCallee === nextCallee) continue;
 			if (!KNOWN_BUILD_CALLEES.has(existingCallee)) return null;
 		} else if (existingCallee === nextCallee) {
-			const mergedInitializer = buildMergedCallInitializer(existingProperty.initializer, existingSourceFile, nextProperty.initializer, newSourceFile);
-			if (mergedInitializer === null) return null;
+			if (existingProperty.value.type !== "CallExpression" || nextProperty.value.type !== "CallExpression") return null;
+			const mergedInitializer = buildMergedCallInitializer({
+				callExpression: existingProperty.value,
+				source: existing.source
+			}, {
+				callExpression: nextProperty.value,
+				source: next.source
+			});
+			if (!mergedInitializer) return null;
 			nextInitializerText = mergedInitializer;
 		}
 		propertyEdits.push({
-			start: existingProperty.initializer.getStart(existingSourceFile) - objectStart,
-			end: existingProperty.initializer.end - objectStart,
+			start: existingProperty.value.start - objectStart,
+			end: existingProperty.value.end - objectStart,
 			text: nextInitializerText
 		});
 	}
 	let mergedText = objectText;
-	for (const edit of propertyEdits.sort((a, b) => b.start - a.start)) mergedText = mergedText.slice(0, edit.start) + edit.text + mergedText.slice(edit.end);
-	return appendMissingProperties(mergedText, missingPropertyTexts, existingObject.properties.length > 0);
-};
-const rebuildImportBlock = (sourceText, sourceFile, scaffold) => {
-	const importDeclarations = sourceFile.statements.filter(ts.isImportDeclaration);
-	if (importDeclarations.length === 0) return {
+	for (const edit of propertyEdits.sort((left, right) => right.start - left.start)) mergedText = mergedText.slice(0, edit.start) + edit.text + mergedText.slice(edit.end);
+	return appendMissingProperties(mergedText, missingPropertyTexts, existing.objectExpression.properties.length > 0);
+};
+const isConfigCallStatement = (statement) => statement.type === "ExpressionStatement" && statement.expression.type === "CallExpression" && statement.expression.callee.type === "Identifier" && statement.expression.callee.name === "config";
+const getManagedHelperName = (statement) => {
+	if (statement.type !== "VariableDeclaration") return null;
+	const declaration = statement.declarations[0];
+	if (declaration?.id.type !== "Identifier") return null;
+	return MANAGED_HELPER_NAMES.has(declaration.id.name) ? declaration.id.name : null;
+};
+const rebuildImportBlock = (source, scaffold) => {
+	const importDeclarations = source.program.body.filter((statement) => statement.type === "ImportDeclaration");
+	const firstImport = importDeclarations[0];
+	const lastImport = importDeclarations.at(-1);
+	if (!firstImport || !lastImport) return {
 		start: 0,
 		end: 0,
 		text: `${renderImportStatements(scaffold.imports)}\n\n`
 	};
-	const preservedImportTexts = importDeclarations.filter((declaration) => {
-		const moduleSpecifier = declaration.moduleSpecifier;
-		return ts.isStringLiteral(moduleSpecifier) && !MANAGED_IMPORT_PACKAGES.has(moduleSpecifier.text);
-	}).map((declaration) => trimStatementText(sourceText.slice(declaration.getFullStart(), declaration.end)));
+	const preservedImportTexts = importDeclarations.filter((declaration) => !MANAGED_IMPORT_PACKAGES.has(declaration.source.value)).map((declaration) => source.text.slice(getTopLevelFullStart(source, declaration), declaration.end).trim());
 	const managedImportText = renderImportStatements(scaffold.imports);
 	const nextImportBlock = [...preservedImportTexts, managedImportText].filter(Boolean).join("\n");
 	return {
-		start: importDeclarations[0].getFullStart(),
-		end: importDeclarations.at(-1).end,
+		start: getTopLevelFullStart(source, firstImport),
+		end: lastImport.end,
 		text: `${nextImportBlock}\n\n`
 	};
 };
-const rebuildManagedBody = (sourceText, sourceFile, exportAssignment, scaffold) => {
-	const statementsBeforeExport = sourceFile.statements.filter((statement) => !ts.isImportDeclaration(statement) && statement.pos < exportAssignment.pos);
+const rebuildManagedBody = (source, exportStart, scaffold) => {
+	const statementsBeforeExport = source.program.body.filter((statement) => statement.type !== "ImportDeclaration" && statement.start < exportStart);
 	const managedHelpers = new Map(scaffold.helperStatements.map((statement) => [statement.name, statement]));
 	const emittedHelpers = /* @__PURE__ */ new Set();
 	const bodyStatements = [];
 	for (const statement of statementsBeforeExport) {
 		if (isConfigCallStatement(statement)) continue;
-		const helperName = isManagedHelperStatement(statement);
+		const helperName = getManagedHelperName(statement);
 		if (!helperName) {
-			bodyStatements.push(getStatementText(sourceText, statement));
+			bodyStatements.push(getStatementText(source, statement));
 			continue;
 		}
 		const helper = managedHelpers.get(helperName);
 		if (!helper) continue;
-		const mergedHelperStatement = mergeHelperStatement(getStatementText(sourceText, statement), helper);
-		if (!mergedHelperStatement) return null;
+		const mergedHelper = mergeHelperStatement(getStatementText(source, statement), helper);
+		if (!mergedHelper) return null;
 		emittedHelpers.add(helperName);
-		bodyStatements.push(mergedHelperStatement);
+		bodyStatements.push(mergedHelper);
 	}
 	for (const helper of scaffold.helperStatements) if (!emittedHelpers.has(helper.name)) bodyStatements.push(helper.code.trim());
 	const bodyText = bodyStatements.filter(Boolean).join("\n\n");
 	const configStatement = `config({ path: ".env.hotupdater" });`;
 	const managedBody = bodyText ? `\n\n${configStatement}\n\n${bodyText}\n\n` : `\n\n${configStatement}\n\n`;
 	return {
-		start: sourceFile.statements.filter(ts.isImportDeclaration).at(-1)?.end ?? 0,
-		end: exportAssignment.getFullStart(),
+		start: source.program.body.filter((statement) => statement.type === "ImportDeclaration").at(-1)?.end ?? 0,
+		end: exportStart,
 		text: managedBody
 	};
 };
+const applyTextEdits = (sourceText, edits) => {
+	let mergedText = sourceText;
+	for (const edit of [...edits].sort((left, right) => right.start - left.start)) mergedText = mergedText.slice(0, edit.start) + edit.text + mergedText.slice(edit.end);
+	return mergedText;
+};
+const mergeHotUpdaterConfigText = (existingText, scaffold) => {
+	const existingSource = parseConfigSource(existingText);
+	const nextSource = parseConfigSource(scaffold.text);
+	if (!existingSource || !nextSource) return { reason: "Existing config is not a supported `export default defineConfig({ ... })` shape." };
+	const existingConfig = findDefineConfigObject(existingSource);
+	const nextConfig = findDefineConfigObject(nextSource);
+	if (!existingConfig || !nextConfig) return { reason: "Existing config is not a supported `export default defineConfig({ ... })` shape." };
+	const nextObjectText = updateManagedObject({
+		objectExpression: existingConfig.objectExpression,
+		source: existingSource
+	}, {
+		objectExpression: nextConfig.objectExpression,
+		source: nextSource
+	});
+	if (!nextObjectText) return { reason: "Existing config uses dynamic build/storage/database expressions that cannot be merged safely." };
+	const bodyEdit = rebuildManagedBody(existingSource, getTopLevelFullStart(existingSource, existingConfig.exportDeclaration), scaffold);
+	if (!bodyEdit) return { reason: "Existing helper declarations could not be merged safely." };
+	return { text: applyTextEdits(existingText, [
+		{
+			start: existingConfig.objectExpression.start,
+			end: existingConfig.objectExpression.end,
+			text: nextObjectText
+		},
+		bodyEdit,
+		rebuildImportBlock(existingSource, scaffold)
+	]) };
+};
+const extractCallIdentifier = (initializer) => {
+	const match = /^\s*([A-Za-z_$][\w$]*)\s*\(/.exec(initializer);
+	if (!match) throw new Error(`Failed to extract call identifier from "${initializer}"`);
+	return match[1];
+};
 const createHotUpdaterConfigScaffold = ({ build, storage, database, extraImports = [], helperStatements = [], updateStrategy = "appVersion" }) => {
 	const intermediateCode = helperStatements.map((statement) => statement.code.trim()).filter(Boolean).join("\n\n");
 	const builder = new ConfigBuilder().setBuildType(build).setStorage(storage).setDatabase(database);
@@ -43540,7 +43602,7 @@ const createHotUpdaterConfigScaffoldFromBuilder = (builder, { helperStatements =
 };
 const writeHotUpdaterConfig = async (scaffold, filePath = HOT_UPDATER_CONFIG_PATH) => {
 	const existingText = await fs$1.readFile(filePath, "utf-8").catch((error) => {
-		if (error.code === "ENOENT") return null;
+		if (error instanceof Error && "code" in error && error.code === "ENOENT") return null;
 		throw error;
 	});
 	if (existingText === null) {
@@ -43550,45 +43612,155 @@ const writeHotUpdaterConfig = async (scaffold, filePath = HOT_UPDATER_CONFIG_PAT
 			path: filePath
 		};
 	}
-	const existingSourceFile = createSnippetSourceFile(existingText);
-	const existingConfig = findDefineConfigObject(existingSourceFile);
-	const nextSourceFile = createSnippetSourceFile(scaffold.text);
-	const nextConfig = findDefineConfigObject(nextSourceFile);
-	if (!existingConfig || !nextConfig) return {
+	const mergeResult = mergeHotUpdaterConfigText(existingText, scaffold);
+	if ("reason" in mergeResult) return {
 		status: "skipped",
 		path: filePath,
-		reason: "Existing config is not a supported `export default defineConfig({ ... })` shape."
+		reason: mergeResult.reason
 	};
-	const nextObjectText = updateManagedObject(existingText, existingConfig.objectLiteral, nextConfig.objectLiteral, existingSourceFile, nextSourceFile);
-	if (!nextObjectText) return {
-		status: "skipped",
-		path: filePath,
-		reason: "Existing config uses dynamic build/storage/database expressions that cannot be merged safely."
+	await fs$1.writeFile(filePath, mergeResult.text, "utf-8");
+	return {
+		status: "merged",
+		path: filePath
 	};
-	const objectEdit = {
-		start: existingConfig.objectLiteral.getStart(existingSourceFile),
-		end: existingConfig.objectLiteral.end,
-		text: nextObjectText
+};
+//#endregion
+//#region src/initOptions.ts
+var InitError = class extends Error {
+	name = "InitError";
+};
+var MissingInitInputsError = class extends InitError {
+	name = "MissingInitInputsError";
+	constructor(missingInputs) {
+		super(["Init is missing required inputs:", ...missingInputs.map((input) => `- ${input}`)].join("\n"));
+		this.missingInputs = missingInputs;
+	}
+};
+var InitEnvFileError = class extends InitError {
+	name = "InitEnvFileError";
+};
+const assertInitInputs = ({ inputs, strict }) => {
+	if (!strict) return;
+	const missingInputs = getMissingInitInputs(inputs);
+	if (missingInputs.length > 0) throw new MissingInitInputsError(missingInputs);
+};
+const getMissingInitInputs = (inputs) => Object.entries(inputs).filter(([, value]) => !value?.trim()).map(([key]) => key);
+//#endregion
+//#region src/hotUpdaterEnv.ts
+const HOT_UPDATER_ENV_PATH = ".env.hotupdater";
+const unquoteEnvValue = (value) => {
+	const trimmed = value.trim();
+	if (trimmed.startsWith("\"") && trimmed.endsWith("\"")) try {
+		const parsed = JSON.parse(trimmed);
+		return typeof parsed === "string" ? parsed : trimmed.slice(1, -1);
+	} catch {
+		return trimmed.slice(1, -1);
+	}
+	return trimmed.startsWith("'") && trimmed.endsWith("'") ? trimmed.slice(1, -1) : trimmed;
+};
+const parseEnv = (content) => {
+	const env = {};
+	for (const line of content.split("\n")) {
+		const trimmed = line.trim();
+		if (!trimmed || trimmed.startsWith("#") || !trimmed.includes("=")) continue;
+		const separatorIndex = trimmed.indexOf("=");
+		const key = trimmed.slice(0, separatorIndex).trim();
+		if (key) env[key] = unquoteEnvValue(trimmed.slice(separatorIndex + 1));
+	}
+	return env;
+};
+const readEnvFile = async (filePath, allowMissing) => {
+	let content;
+	try {
+		content = await fs$1.readFile(filePath, "utf-8");
+	} catch (error) {
+		if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+			if (allowMissing) return {};
+			throw new InitEnvFileError(`Init environment file not found: ${filePath}`);
+		}
+		throw error;
+	}
+	return parseEnv(content);
+};
+const getHotUpdaterInitInputEnv = ({ env, managedEnv }, nonInteractive) => nonInteractive ? env : managedEnv;
+const readHotUpdaterInitEnv = async (cwd, envFile) => {
+	const savedEnvPath = path.resolve(cwd, HOT_UPDATER_ENV_PATH);
+	const savedEnv = await readEnvFile(savedEnvPath, true);
+	if (!envFile) return {
+		env: {},
+		managedEnv: savedEnv
 	};
-	const importEdit = rebuildImportBlock(existingText, existingSourceFile, scaffold);
-	const bodyEdit = rebuildManagedBody(existingText, existingSourceFile, existingConfig.exportAssignment, scaffold);
-	if (!bodyEdit) return {
-		status: "skipped",
-		path: filePath,
-		reason: "Existing helper declarations could not be merged safely."
+	const inputEnvPath = path.resolve(cwd, envFile);
+	if (inputEnvPath === savedEnvPath) return {
+		env: savedEnv,
+		managedEnv: savedEnv
 	};
-	let mergedText = existingText;
-	for (const edit of [
-		objectEdit,
-		bodyEdit,
-		importEdit
-	].sort((a, b) => b.start - a.start)) mergedText = mergedText.slice(0, edit.start) + edit.text + mergedText.slice(edit.end);
-	await fs$1.writeFile(filePath, mergedText, "utf-8");
+	const inputEnv = await readEnvFile(inputEnvPath, false);
 	return {
-		status: "merged",
-		path: filePath
+		env: {
+			...savedEnv,
+			...inputEnv
+		},
+		inputEnv,
+		managedEnv: savedEnv
 	};
 };
+const readHotUpdaterEnv = async (cwd) => {
+	const { managedEnv } = await readHotUpdaterInitEnv(cwd);
+	return managedEnv;
+};
+const getHotUpdaterEnvValue = (env, key) => {
+	if (process.env[key] !== void 0) return process.env[key]?.trim() || void 0;
+	return env[key]?.trim() || void 0;
+};
+//#endregion
+//#region src/initProvider.ts
+const defineInitProvider = (provider) => provider;
+const shouldAutoSelectOnlyInitResource = ({ availableResourceCount, savedIdentifier }) => savedIdentifier === void 0 && availableResourceCount === 1;
+const getInitProviderTextPromptValues = (prompt, savedValue) => ({
+	initialValue: savedValue ?? prompt.defaultValue,
+	placeholder: prompt.placeholder ?? prompt.defaultValue
+});
+const resolveInitProviderInput = (env, input) => getHotUpdaterEnvValue(env, input.envKey);
+const resolveInitProviderInputs = (env, provider) => Object.fromEntries(Object.entries(provider.inputs).map(([name, input]) => [name, resolveInitProviderInput(env, input)]));
+const getMissingInitProviderInputs = ({ inputs, preflightOnly = false, provider }) => Object.entries(provider.inputs).filter(([name, input]) => {
+	if (preflightOnly && input.preflight === false) return false;
+	const required = input.requiredWhen ? input.requiredWhen(inputs) : !input.optional;
+	const value = inputs[name];
+	return required && (!value?.trim() || input.validate?.(value) === false);
+}).map(([, input]) => input.envKey);
+const assertInitProviderInputs = ({ inputs, provider, strict }) => {
+	if (!strict) return;
+	const missingInputs = getMissingInitProviderInputs({
+		inputs,
+		provider
+	});
+	if (missingInputs.length > 0) throw new MissingInitInputsError(missingInputs);
+};
+const hasNewConsentInput = (provider, inputs, existingEnv) => Object.entries(provider.inputs).some(([name, input]) => {
+	if (input.persistence !== "with-consent") return false;
+	const value = inputs[name];
+	return value !== void 0 && value !== existingEnv[input.envKey]?.trim();
+});
+const confirmInitInputPersistence = async ({ existingEnv, inputs, nonInteractive, provider }) => {
+	if (!hasNewConsentInput(provider, inputs, existingEnv)) return true;
+	if (nonInteractive) return false;
+	const confirmed = await p.confirm({
+		message: "Save these init inputs to .env.hotupdater for future infrastructure updates?",
+		initialValue: true
+	});
+	if (p.isCancel(confirmed)) process.exit(1);
+	if (!confirmed) p.log.info("Credential inputs were not saved; provide them again for future infrastructure updates.");
+	return confirmed;
+};
+const getInitProviderEnvVars = ({ includeConsentInputs, inputs, provider }) => {
+	const env = {};
+	for (const [name, input] of Object.entries(provider.inputs)) {
+		const value = inputs[name];
+		if (value !== void 0 && (input.persistence !== "with-consent" || includeConsentInputs)) env[input.envKey] = value;
+	}
+	return env;
+};
 //#endregion
 //#region ../../node_modules/.pnpm/es-toolkit@1.47.0/node_modules/es-toolkit/dist/predicate/isPlainObject.mjs
 /**
@@ -43766,7 +43938,7 @@ const getDefaultConfig = () => {
 		releaseChannel: "production",
 		updateStrategy: "appVersion",
 		compressStrategy: "zip",
-		fingerprint: { extraSources: [] },
+		fingerprint: {},
 		patch: {
 			enabled: true,
 			maxBaseBundles: 3
@@ -43829,10 +44001,54 @@ const log = {
 };
 //#endregion
 //#region src/makeEnv.ts
+const isFileSystemError = (error) => error instanceof Error && "code" in error;
+const assertSafeExistingTarget = async (filePath) => {
+	try {
+		const target = await fs$3.lstat(filePath);
+		if (target.isSymbolicLink() || !target.isFile()) throw new Error(`Refusing to write init environment values to a non-regular file: ${filePath}`);
+	} catch (error) {
+		if (isFileSystemError(error) && error.code === "ENOENT") return;
+		throw error;
+	}
+};
+const serializeEnvValue = (value) => {
+	if (value.includes("\0") || value.includes("\r") || value.includes("\n")) throw new Error("Environment values cannot contain NUL or newlines.");
+	return /^[A-Za-z0-9_./:@%+,=-]*$/.test(value) ? value : JSON.stringify(value);
+};
+const formatEnvLine = (key, value) => {
+	if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(key)) throw new Error(`Invalid environment variable name: ${key}`);
+	return `${key}=${serializeEnvValue(value)}`;
+};
+const formatComment = (comment) => {
+	if (comment.includes("\0") || comment.includes("\r") || comment.includes("\n")) throw new Error("Environment comments cannot contain NUL or newlines.");
+	return `# ${comment}`;
+};
+const writeEnvAtomically = async (filePath, content) => {
+	const resolvedPath = path$1.resolve(filePath);
+	const temporaryPath = path$1.join(path$1.dirname(resolvedPath), `.${path$1.basename(resolvedPath)}.${randomUUID()}.tmp`);
+	let renamed = false;
+	try {
+		await fs$3.writeFile(temporaryPath, content, {
+			encoding: "utf-8",
+			flag: "wx",
+			mode: 384
+		});
+		await fs$3.rename(temporaryPath, resolvedPath);
+		renamed = true;
+	} finally {
+		if (!renamed) await fs$3.rm(temporaryPath, { force: true });
+	}
+};
 const makeEnv = async (newEnvVars, filePath = ".env.hotupdater", options) => {
 	try {
+		const resolvedFilePath = path$1.resolve(filePath);
+		await assertSafeExistingTarget(resolvedFilePath);
 		const preserveKeys = new Set(options?.preserveKeys ?? []);
-		const existingContent = await fs$1.readFile(filePath, "utf-8").catch(() => "");
+		const removeKeys = new Set(options?.removeKeys ?? []);
+		const existingContent = await fs$3.readFile(resolvedFilePath, "utf-8").catch((error) => {
+			if (isFileSystemError(error) && error.code === "ENOENT") return "";
+			throw error;
+		});
 		const lines = existingContent ? existingContent.split("\n") : [];
 		const processedKeys = /* @__PURE__ */ new Set();
 		const updatedLines = [];
@@ -43848,6 +44064,7 @@ const makeEnv = async (newEnvVars, filePath = ".env.hotupdater", options) => {
 					const nextLine = (lines[i + 1] ?? "").trim();
 					if (nextLine && !nextLine.startsWith("#") && nextLine.includes("=")) {
 						const [possibleKey = ""] = nextLine.split("=");
+						if (removeKeys.has(possibleKey.trim())) continue;
 						if (Object.hasOwn(newEnvVars, possibleKey.trim()) && !preserveKeys.has(possibleKey.trim())) continue;
 					}
 				}
@@ -43857,6 +44074,7 @@ const makeEnv = async (newEnvVars, filePath = ".env.hotupdater", options) => {
 			if (trimmedLine.includes("=")) {
 				const [keyPart] = line.split("=");
 				const key = keyPart?.trim() ?? "";
+				if (removeKeys.has(key)) continue;
 				if (Object.hasOwn(newEnvVars, key)) {
 					processedKeys.add(key);
 					if (preserveKeys.has(key)) {
@@ -43865,18 +44083,18 @@ const makeEnv = async (newEnvVars, filePath = ".env.hotupdater", options) => {
 					}
 					const newValue = newEnvVars[key];
 					if (typeof newValue === "object" && newValue !== null) {
-						updatedLines.push(`# ${newValue.comment}`);
-						updatedLines.push(`${key}=${newValue.value}`);
-					} else updatedLines.push(`${key}=${newValue}`);
+						updatedLines.push(formatComment(newValue.comment));
+						updatedLines.push(formatEnvLine(key, newValue.value));
+					} else updatedLines.push(formatEnvLine(key, newValue));
 				} else updatedLines.push(line);
 			} else updatedLines.push(line);
 		}
 		for (const [key, val] of Object.entries(newEnvVars)) if (!processedKeys.has(key)) if (typeof val === "object" && val !== null) {
-			updatedLines.push(`# ${val.comment}`);
-			updatedLines.push(`${key}=${val.value}`);
-		} else updatedLines.push(`${key}=${val}`);
+			updatedLines.push(formatComment(val.comment));
+			updatedLines.push(formatEnvLine(key, val.value));
+		} else updatedLines.push(formatEnvLine(key, val));
 		const updatedContent = updatedLines.join("\n");
-		await fs$1.writeFile(filePath, updatedContent, "utf-8");
+		await writeEnvAtomically(resolvedFilePath, updatedContent);
 		return updatedContent;
 	} catch (error) {
 		console.error("Error while updating .env.hotupdater file:", error);
@@ -44228,4 +44446,4 @@ function transformTemplate(templateString, values) {
 	return result;
 }
 //#endregion
-export { BuildLogger, ConfigBuilder, HOT_UPDATER_SERVER_PACKAGE_VERSION_ENV, HotUpdateDirUtil, LEGACY_BUNDLE_ERROR, banner, typedColors as colors, copyDirToTmp, createCopiedBundleArchive, createHotUpdaterConfigScaffold, createHotUpdaterConfigScaffoldFromBuilder, createLogWriter, createTarBr, createTarBrTargetFiles, createTarGz, createTarGzTargetFiles, createZip, createZipTargetFiles, decryptJson, encryptJson, ensureInstallPackages, getAndroidSdkPath, getCwd, getPackageManager, getReactNativeMetadatas, link, loadConfig, log, makeEnv, p, printBanner, promoteBundle, readPackageUp, renderImportStatements, resolveHotUpdaterServerVersion, resolvePackageVersion, stripAnsi, transformEnv, transformTemplate, writeHotUpdaterConfig };
+export { BuildLogger, ConfigBuilder, HOT_UPDATER_SERVER_PACKAGE_VERSION_ENV, HotUpdateDirUtil, InitEnvFileError, InitError, LEGACY_BUNDLE_ERROR, MissingInitInputsError, assertInitInputs, assertInitProviderInputs, banner, typedColors as colors, confirmInitInputPersistence, copyDirToTmp, createCopiedBundleArchive, createHotUpdaterConfigScaffold, createHotUpdaterConfigScaffoldFromBuilder, createLogWriter, createTarBr, createTarBrTargetFiles, createTarGz, createTarGzTargetFiles, createZip, createZipTargetFiles, decryptJson, defineInitProvider, encryptJson, ensureInstallPackages, getAndroidSdkPath, getCwd, getHotUpdaterEnvValue, getHotUpdaterInitInputEnv, getInitProviderEnvVars, getInitProviderTextPromptValues, getMissingInitInputs, getMissingInitProviderInputs, getPackageManager, getReactNativeMetadatas, link, loadConfig, log, makeEnv, p, printBanner, promoteBundle, readHotUpdaterEnv, readHotUpdaterInitEnv, readPackageUp, renderImportStatements, resolveHotUpdaterServerVersion, resolveInitProviderInput, resolveInitProviderInputs, resolvePackageVersion, shouldAutoSelectOnlyInitResource, stripAnsi, transformEnv, transformTemplate, writeHotUpdaterConfig };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hot-updater/cli-tools",
-  "version": "0.35.8",
+  "version": "0.35.10",
   "type": "module",
   "engines": {
     "node": ">=20.19.0"
@@ -46,11 +46,11 @@
     "access": "public"
   },
   "dependencies": {
-    "oxc-transform": "0.121.0",
-    "typescript": "6.0.2",
+    "oxc-parser": "0.141.0",
+    "oxc-transform": "0.141.0",
     "unconfig": "7.5.0",
-    "@hot-updater/core": "0.35.8",
-    "@hot-updater/plugin-core": "0.35.8"
+    "@hot-updater/core": "0.35.10",
+    "@hot-updater/plugin-core": "0.35.10"
   },
   "devDependencies": {
     "@clack/prompts": "1.7.0",
@@ -65,7 +65,7 @@
     "semver": "^7.6.3",
     "tar": "^7.5.16",
     "workspace-tools": "^0.41.7",
-    "@hot-updater/test-utils": "0.35.8"
+    "@hot-updater/test-utils": "0.35.10"
   },
   "inlinedDependencies": {
     "@babel/code-frame": "7.29.0",