@hot-updater/cli-tools 0.29.5 → 0.29.6

package/dist/index.mjs

@@ -24,13 +24,14 @@ import Stream, { Duplex, PassThrough as PassThrough$1, Readable as Readable$1, T
 import { StringDecoder } from "node:string_decoder";
 import assert$1 from "node:assert";
 import { randomBytes } from "node:crypto";
-import fsp from "node:fs/promises";
+import fsPromises from "node:fs/promises";
 import { fileURLToPath } from "node:url";
 import { ChildProcess, execFile, spawn, spawnSync } from "node:child_process";
 import { scheduler, setImmediate as setImmediate$1, setTimeout as setTimeout$1 } from "node:timers/promises";
 import { serialize } from "node:v8";
 import { finished } from "node:stream/promises";
 import { Buffer as Buffer$2 } from "node:buffer";
+import ts from "typescript";
 import { loadConfig as loadConfig$1 } from "unconfig";
 import { transformSync } from "oxc-transform";
 //#region ../../node_modules/.pnpm/picocolors@1.1.1/node_modules/picocolors/picocolors.js
@@ -21882,6 +21883,53 @@ const printBanner = (version) => {
 };
 //#endregion
 //#region src/ConfigBuilder.ts
+const normalizeImportInfos = (imports) => {
+	const collectedImports = /* @__PURE__ */ new Map();
+	for (const info of imports) {
+		const existing = collectedImports.get(info.pkg);
+		if (existing) {
+			if (info.named) for (const namedImport of info.named) existing.named.add(namedImport);
+			if (info.defaultOrNamespace && !existing.defaultOrNamespace) existing.defaultOrNamespace = info.defaultOrNamespace;
+			if (info.sideEffect && !existing.sideEffect) existing.sideEffect = true;
+			continue;
+		}
+		collectedImports.set(info.pkg, {
+			named: new Set(info.named ?? []),
+			defaultOrNamespace: info.defaultOrNamespace,
+			sideEffect: info.sideEffect ?? false
+		});
+	}
+	return Array.from(collectedImports.entries()).sort(([a], [b]) => {
+		const isABuild = a.startsWith("@hot-updater/");
+		if (isABuild !== b.startsWith("@hot-updater/")) return isABuild ? -1 : 1;
+		if (a === "dotenv/config") return -1;
+		if (b === "dotenv/config") return 1;
+		const isAdminA = a === "firebase-admin";
+		if (isAdminA !== (b === "firebase-admin")) return isAdminA ? -1 : 1;
+		return a.localeCompare(b);
+	}).map(([pkg, info]) => ({
+		pkg,
+		named: Array.from(info.named).sort(),
+		defaultOrNamespace: info.defaultOrNamespace,
+		sideEffect: info.sideEffect ?? false
+	}));
+};
+const renderImportStatements = (imports) => {
+	const importLines = [];
+	for (const info of normalizeImportInfos(imports)) {
+		if (info.sideEffect) {
+			importLines.push(`import "${info.pkg}";`);
+			continue;
+		}
+		if (info.defaultOrNamespace) {
+			if (info.pkg === "firebase-admin" && (info.named?.length ?? 0) > 0) importLines.push(`import ${info.defaultOrNamespace}, { ${info.named.join(", ")} } from "${info.pkg}";`);
+			else importLines.push(`import ${info.defaultOrNamespace} from "${info.pkg}";`);
+			continue;
+		}
+		if ((info.named?.length ?? 0) > 0) importLines.push(`import { ${info.named.join(", ")} } from "${info.pkg}";`);
+	}
+	return importLines.join("\n");
+};
 var ConfigBuilder = class {
 	buildType = null;
 	storageInfo = null;
@@ -21915,28 +21963,13 @@ var ConfigBuilder = class {
 	addImports(imports) {
 		for (const imp of imports) this.addImport(imp);
 	}
-	generateImportStatements() {
-		const importLines = [];
-		const sortedPackages = Array.from(this.collectedImports.keys()).sort((a, b) => {
-			const isABuild = a.startsWith("@hot-updater/");
-			if (isABuild !== b.startsWith("@hot-updater/")) return isABuild ? -1 : 1;
-			if (a === "dotenv/config") return -1;
-			if (b === "dotenv/config") return 1;
-			const isAdminA = a === "firebase-admin";
-			if (isAdminA !== (b === "firebase-admin")) return isAdminA ? -1 : 1;
-			return a.localeCompare(b);
-		});
-		for (const pkg of sortedPackages) {
-			const info = this.collectedImports.get(pkg);
-			if (info.sideEffect) importLines.push(`import "${pkg}";`);
-			else if (info.defaultOrNamespace) if (pkg === "firebase-admin" && info.named.size > 0) importLines.push(`import ${info.defaultOrNamespace}, { ${Array.from(info.named).sort().join(", ")} } from "${pkg}";`);
-			else importLines.push(`import ${info.defaultOrNamespace} from "${pkg}";`);
-			else if (info.named.size > 0) {
-				const namedPart = Array.from(info.named).sort().join(", ");
-				importLines.push(`import { ${namedPart} } from "${pkg}";`);
-			}
-		}
-		return importLines.join("\n");
+	getImportInfos() {
+		return normalizeImportInfos(Array.from(this.collectedImports.entries()).map(([pkg, info]) => ({
+			pkg,
+			named: Array.from(info.named),
+			defaultOrNamespace: info.defaultOrNamespace,
+			sideEffect: info.sideEffect ?? false
+		})));
 	}
 	generateBuildConfigString() {
 		if (!this.buildType) throw new Error("Build type must be set using .setBuildType()");
@@ -21978,13 +22011,14 @@ var ConfigBuilder = class {
 		this.intermediateCode = code.trim();
 		return this;
 	}
-	getResult() {
+	getScaffold() {
 		if (!this.buildType) throw new Error("Build type must be set using .setBuildType()");
 		if (!this.storageInfo) throw new Error("Storage config must be set using .setStorage()");
 		if (!this.databaseInfo) throw new Error("Database config must be set using .setDatabase()");
-		const importStatements = this.generateImportStatements();
+		const imports = this.getImportInfos();
+		const importStatements = renderImportStatements(imports);
 		const buildConfigString = this.generateBuildConfigString();
-		return `
+		const text = `
 ${importStatements}
 
 config({ path: ".env.hotupdater" });
@@ -21997,6 +22031,17 @@ export default defineConfig({
   updateStrategy: "appVersion", // or "fingerprint"
 });
 `.trim();
+		return {
+			imports,
+			buildConfigString,
+			storageConfigString: this.storageInfo.configString,
+			databaseConfigString: this.databaseInfo.configString,
+			intermediateCode: this.intermediateCode,
+			text
+		};
+	}
+	getResult() {
+		return this.getScaffold().text;
 	}
 };
 //#endregion
@@ -25943,7 +25988,7 @@ const mkdir = (dir, opt, cb) => {
 		else cb();
 	};
 	if (dir === cwd) return checkCwd(dir, done);
-	if (preserve) return fsp.mkdir(dir, {
+	if (preserve) return fsPromises.mkdir(dir, {
 		mode,
 		recursive: true
 	}).then((made) => done(null, made ?? void 0), done);
@@ -42010,7 +42055,7 @@ async function findUp(name, { cwd = N.cwd(), type = "file", stopAt } = {}) {
 	while (directory) {
 		const filePath = isAbsoluteName ? name : path$1.join(directory, name);
 		try {
-			const stats = await fsp.stat(filePath);
+			const stats = await fsPromises.stat(filePath);
 			if (type === "file" && stats.isFile() || type === "directory" && stats.isDirectory()) return filePath;
 		} catch {}
 		if (directory === stopAt || directory === root) break;
@@ -47079,7 +47124,7 @@ const _readPackage = (file, normalize) => {
 	return json;
 };
 async function readPackage({ cwd, normalize = true } = {}) {
-	return _readPackage(await fsp.readFile(getPackagePath(cwd), "utf8"), normalize);
+	return _readPackage(await fsPromises.readFile(getPackagePath(cwd), "utf8"), normalize);
 }
 //#endregion
 //#region ../../node_modules/.pnpm/read-package-up@11.0.0/node_modules/read-package-up/index.js
@@ -47538,6 +47583,363 @@ 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 MANAGED_IMPORT_PACKAGES = new Set([
+	"dotenv",
+	"firebase-admin",
+	"hot-updater",
+	"@aws-sdk/credential-provider-sso",
+	"@hot-updater/aws",
+	"@hot-updater/bare",
+	"@hot-updater/cloudflare",
+	"@hot-updater/expo",
+	"@hot-updater/firebase",
+	"@hot-updater/rock",
+	"@hot-updater/supabase"
+]);
+const MANAGED_HELPER_NAMES = new Set(["commonOptions", "credential"]);
+const KNOWN_BUILD_CALLEES = new Set([
+	"bare",
+	"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;
+	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;
+	return {
+		sourceFile,
+		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;
+	}
+	return null;
+};
+const trimStatementText = (text) => text.trim();
+const getStatementText = (sourceText, statement) => trimStatementText(sourceText.slice(statement.getFullStart(), statement.end));
+const getObjectTrailingComma = (text) => {
+	const closeBraceIndex = text.lastIndexOf("}");
+	if (closeBraceIndex === -1) return false;
+	let index = closeBraceIndex - 1;
+	while (index >= 0 && /\s/.test(text[index] ?? "")) index -= 1;
+	return (text[index] ?? "") === ",";
+};
+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 minIndent = indents.length > 0 ? Math.min(...indents) : 0;
+	return lines.map((line) => line.slice(minIndent)).join("\n");
+};
+const indentBlock = (text, indent) => dedentBlock(text).split("\n").map((line) => `${indent}${line}`).join("\n");
+const appendMissingProperties = (objectText, propertyTexts, hasExistingProperties) => {
+	if (propertyTexts.length === 0) return objectText;
+	const closingIndent = /\n([ \t]*)\}$/.exec(objectText)?.[1] ?? "";
+	const childIndent = objectText.match(/\n([ \t]+)[^\s]/)?.[1] ?? `${closingIndent}  `;
+	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 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 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());
+			continue;
+		}
+		const propertyName = getPropertyName(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;
+			edits.push({
+				start: property.initializer.getStart(existingWrapped.sourceFile) - existingWrapped.offset,
+				end: property.initializer.end - existingWrapped.offset,
+				text: mergedInitializer
+			});
+		}
+	}
+	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);
+		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));
+		if (!mergedObjectLiteral) return null;
+		return `${existingCallee}(${mergedObjectLiteral})`;
+	}
+	return existingCall.getText(existingSourceFile);
+};
+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 = (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;
+};
+const mergeHelperStatement = (existingStatementText, helper) => {
+	if (helper.strategy === "preserve-existing") return existingStatementText;
+	if (helper.strategy === "replace") return helper.code.trim();
+	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));
+	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};`;
+};
+const updateManagedObject = (existingText, existingObject, newObject, existingSourceFile, newSourceFile) => {
+	const objectStart = existingObject.getStart(existingSourceFile);
+	const objectText = existingText.slice(objectStart, existingObject.end);
+	const propertyEdits = [];
+	const missingPropertyTexts = [];
+	for (const propertyName of [
+		"build",
+		"storage",
+		"database"
+	]) {
+		const existingProperty = findManagedProperty(existingObject, propertyName);
+		const nextProperty = findManagedProperty(newObject, propertyName);
+		if (!nextProperty) continue;
+		if (!existingProperty) {
+			missingPropertyTexts.push(nextProperty.getText(newSourceFile));
+			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);
+		if (!existingCallee || !nextCallee) return null;
+		let nextInitializerText = nextProperty.initializer.getText(newSourceFile);
+		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;
+			nextInitializerText = mergedInitializer;
+		}
+		propertyEdits.push({
+			start: existingProperty.initializer.getStart(existingSourceFile) - objectStart,
+			end: existingProperty.initializer.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 {
+		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 managedImportText = renderImportStatements(scaffold.imports);
+	const nextImportBlock = [...preservedImportTexts, managedImportText].filter(Boolean).join("\n");
+	return {
+		start: importDeclarations[0].getFullStart(),
+		end: importDeclarations.at(-1).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 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);
+		if (!helperName) {
+			bodyStatements.push(getStatementText(sourceText, statement));
+			continue;
+		}
+		const helper = managedHelpers.get(helperName);
+		if (!helper) continue;
+		const mergedHelperStatement = mergeHelperStatement(getStatementText(sourceText, statement), helper);
+		if (!mergedHelperStatement) return null;
+		emittedHelpers.add(helperName);
+		bodyStatements.push(mergedHelperStatement);
+	}
+	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(),
+		text: managedBody
+	};
+};
+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);
+	for (const extraImport of extraImports) builder.addImport(extraImport);
+	if (intermediateCode) builder.setIntermediateCode(intermediateCode);
+	return createHotUpdaterConfigScaffoldFromBuilder(builder, {
+		helperStatements,
+		updateStrategy
+	});
+};
+const createHotUpdaterConfigScaffoldFromBuilder = (builder, { helperStatements = [], updateStrategy = "appVersion" } = {}) => {
+	const scaffold = builder.getScaffold();
+	return {
+		text: updateStrategy === "appVersion" ? scaffold.text : scaffold.text.replace("updateStrategy: \"appVersion\"", `updateStrategy: "${updateStrategy}"`),
+		imports: scaffold.imports,
+		build: {
+			initializer: scaffold.buildConfigString,
+			callee: extractCallIdentifier(scaffold.buildConfigString)
+		},
+		storage: {
+			initializer: scaffold.storageConfigString,
+			callee: extractCallIdentifier(scaffold.storageConfigString)
+		},
+		database: {
+			initializer: scaffold.databaseConfigString,
+			callee: extractCallIdentifier(scaffold.databaseConfigString)
+		},
+		helperStatements,
+		updateStrategy: `"${updateStrategy}"`
+	};
+};
+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;
+		throw error;
+	});
+	if (existingText === null) {
+		await fs$1.writeFile(filePath, `${scaffold.text}\n`, "utf-8");
+		return {
+			status: "created",
+			path: filePath
+		};
+	}
+	const existingSourceFile = createSnippetSourceFile(existingText);
+	const existingConfig = findDefineConfigObject(existingSourceFile);
+	const nextSourceFile = createSnippetSourceFile(scaffold.text);
+	const nextConfig = findDefineConfigObject(nextSourceFile);
+	if (!existingConfig || !nextConfig) return {
+		status: "skipped",
+		path: filePath,
+		reason: "Existing config is not a supported `export default defineConfig({ ... })` shape."
+	};
+	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."
+	};
+	const objectEdit = {
+		start: existingConfig.objectLiteral.getStart(existingSourceFile),
+		end: existingConfig.objectLiteral.end,
+		text: nextObjectText
+	};
+	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."
+	};
+	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");
+	return {
+		status: "merged",
+		path: filePath
+	};
+};
+//#endregion
 //#region ../../node_modules/.pnpm/es-toolkit@1.32.0/node_modules/es-toolkit/dist/predicate/isPlainObject.mjs
 function isPlainObject(value) {
 	if (!value || typeof value !== "object") return false;
@@ -47659,8 +48061,9 @@ const log = {
 };
 //#endregion
 //#region src/makeEnv.ts
-const makeEnv = async (newEnvVars, filePath = ".env.hotupdater") => {
+const makeEnv = async (newEnvVars, filePath = ".env.hotupdater", options) => {
 	try {
+		const preserveKeys = new Set(options?.preserveKeys ?? []);
 		const existingContent = await fs$1.readFile(filePath, "utf-8").catch(() => "");
 		const lines = existingContent ? existingContent.split("\n") : [];
 		const processedKeys = /* @__PURE__ */ new Set();
@@ -47677,7 +48080,7 @@ const makeEnv = async (newEnvVars, filePath = ".env.hotupdater") => {
 					const nextLine = (lines[i + 1] ?? "").trim();
 					if (nextLine && !nextLine.startsWith("#") && nextLine.includes("=")) {
 						const [possibleKey = ""] = nextLine.split("=");
-						if (Object.hasOwn(newEnvVars, possibleKey.trim())) continue;
+						if (Object.hasOwn(newEnvVars, possibleKey.trim()) && !preserveKeys.has(possibleKey.trim())) continue;
 					}
 				}
 				updatedLines.push(line);
@@ -47688,6 +48091,10 @@ const makeEnv = async (newEnvVars, filePath = ".env.hotupdater") => {
 				const key = keyPart?.trim() ?? "";
 				if (Object.hasOwn(newEnvVars, key)) {
 					processedKeys.add(key);
+					if (preserveKeys.has(key)) {
+						updatedLines.push(line);
+						continue;
+					}
 					const newValue = newEnvVars[key];
 					if (typeof newValue === "object" && newValue !== null) {
 						updatedLines.push(`# ${newValue.comment}`);
@@ -47775,4 +48182,4 @@ function transformTemplate(templateString, values) {
 }
 //#endregion
 var colors = import_picocolors.default;
-export { BuildLogger, ConfigBuilder, HOT_UPDATER_SERVER_PACKAGE_VERSION_ENV, HotUpdateDirUtil, banner, colors, copyDirToTmp, createLogWriter, createTarBr, createTarBrTargetFiles, createTarGz, createTarGzTargetFiles, createZip, createZipTargetFiles, decryptJson, encryptJson, ensureInstallPackages, getAndroidSdkPath, getCwd, getPackageManager, getReactNativeMetadatas, link, loadConfig, log, makeEnv, dist_exports as p, printBanner, resolveHotUpdaterServerVersion, resolvePackageVersion, stripAnsi, transformEnv, transformTemplate };
+export { BuildLogger, ConfigBuilder, HOT_UPDATER_SERVER_PACKAGE_VERSION_ENV, HotUpdateDirUtil, banner, colors, copyDirToTmp, createHotUpdaterConfigScaffold, createHotUpdaterConfigScaffoldFromBuilder, createLogWriter, createTarBr, createTarBrTargetFiles, createTarGz, createTarGzTargetFiles, createZip, createZipTargetFiles, decryptJson, encryptJson, ensureInstallPackages, getAndroidSdkPath, getCwd, getPackageManager, getReactNativeMetadatas, link, loadConfig, log, makeEnv, dist_exports as p, printBanner, renderImportStatements, resolveHotUpdaterServerVersion, resolvePackageVersion, stripAnsi, transformEnv, transformTemplate, writeHotUpdaterConfig };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hot-updater/cli-tools",
-  "version": "0.29.5",
+  "version": "0.29.6",
   "type": "module",
   "description": "CLI utilities for Hot Updater",
   "sideEffects": false,
@@ -40,8 +40,9 @@
   },
   "dependencies": {
     "oxc-transform": "0.121.0",
+    "typescript": "6.0.2",
     "unconfig": "7.5.0",
-    "@hot-updater/plugin-core": "0.29.5"
+    "@hot-updater/plugin-core": "0.29.6"
   },
   "devDependencies": {
     "@clack/prompts": "1.0.1",
@@ -56,9 +57,8 @@
     "read-package-up": "^11.0.0",
     "semver": "^7.6.3",
     "tar": "^7.5.1",
-    "typescript": "6.0.2",
     "workspace-tools": "^0.36.4",
-    "@hot-updater/test-utils": "0.29.5"
+    "@hot-updater/test-utils": "0.29.6"
   },
   "inlinedDependencies": {
     "@babel/code-frame": "7.29.0",