@arkts/image-manager 0.0.2

package/dist/index.mjs

@@ -0,0 +1,629 @@
+import axios, { AxiosError } from "axios";
+import mitt from "mitt";
+import progress from "progress-stream";
+import unzipper from "unzipper";
+
+//#region src/deployer/list.ts
+let DevModel = /* @__PURE__ */ function(DevModel) {
+	DevModel["MCHEMU_AL00CN"] = "MCHEMU-AL00CN";
+	DevModel["PHEMU_FD00"] = "PHEMU-FD00";
+	DevModel["PHEMU_FD01"] = "PHEMU-FD01";
+	DevModel["PHEMU_FD02"] = "PHEMU-FD02";
+	DevModel["PHEMU_FD06"] = "PHEMU-FD06";
+	DevModel["PCEMU_FD00"] = "PCEMU-FD00";
+	DevModel["PCEMU_FD05"] = "PCEMU-FD05";
+	return DevModel;
+}({});
+
+//#endregion
+//#region src/errors/request-url-error.ts
+var RequestUrlError = class extends Error {
+	constructor(message, code, cause) {
+		super(message, { cause });
+		this.message = message;
+		this.code = code;
+		this.cause = cause;
+	}
+};
+
+//#endregion
+//#region src/deployer/image-deployer.ts
+var ImageDeployerImpl = class {
+	options = {};
+	isDefault = true;
+	isCustomize = false;
+	isPublic = true;
+	vendorCountry = "CN";
+	hwHdcPort = "notset";
+	constructor(image, uuid, name, config) {
+		this.image = image;
+		this.config = config;
+		this.options.uuid = uuid;
+		this.options.name = name;
+		Object.assign(this.options, config);
+	}
+	setUuid(uuid) {
+		this.options.uuid = uuid;
+		return this;
+	}
+	setModel(model) {
+		this.options.model = model;
+		return this;
+	}
+	setDevModel(devModel) {
+		this.options.devModel = devModel;
+		return this;
+	}
+	setCpuNumber(cpuNumber) {
+		this.options.cpuNumber = cpuNumber.toString();
+		return this;
+	}
+	setMemoryRamSize(memoryRamSize) {
+		this.options.memoryRamSize = memoryRamSize.toString();
+		return this;
+	}
+	setDataDiskSize(dataDiskSize) {
+		this.options.dataDiskSize = dataDiskSize.toString();
+		return this;
+	}
+	setCoverResolutionWidth(coverResolutionWidth) {
+		this.options.coverResolutionWidth = coverResolutionWidth.toString();
+		return this;
+	}
+	setCoverResolutionHeight(coverResolutionHeight) {
+		this.options.coverResolutionHeight = coverResolutionHeight.toString();
+		return this;
+	}
+	setCoverDiagonalSize(coverDiagonalSize) {
+		this.options.coverDiagonalSize = coverDiagonalSize.toString();
+		return this;
+	}
+	setIsDefault(isDefault) {
+		this.isDefault = isDefault;
+		return this;
+	}
+	setIsCustomize(isCustomize) {
+		this.isCustomize = isCustomize;
+		return this;
+	}
+	setIsPublic(isPublic) {
+		this.isPublic = isPublic;
+		return this;
+	}
+	setHwHdcPort(hwHdcPort) {
+		this.hwHdcPort = hwHdcPort.toString();
+		return this;
+	}
+	setVendorCountry(vendorCountry) {
+		this.vendorCountry = vendorCountry;
+		return this;
+	}
+	async getDevModel() {
+		if (this.options.devModel) return this.options.devModel;
+		const productConfigItem = (await this.image.getProductConfig()).find((item) => item.name === this.config.productName);
+		if (!productConfigItem) throw new Error(`Product config item ${this.config.productName} not found`);
+		if (productConfigItem.devModel) return productConfigItem.devModel;
+		const defaultProductConfigItem = (await this.image.getProductConfig(true)).find((item) => item.name === this.config.productName);
+		if (!defaultProductConfigItem) throw new Error(`Default product config item ${this.config.productName} not found`);
+		if (defaultProductConfigItem.devModel) return defaultProductConfigItem.devModel;
+	}
+	async buildList() {
+		if (!(await this.image.getProductConfig()).find((item) => item.name === this.config.productName)) throw new Error(`Product config item ${this.config.productName} not found`);
+		return {
+			...this.options,
+			"imageDir": this.image.getPath().split(",").join(this.image.getImageManager().getOptions().path.sep) + this.image.getImageManager().getOptions().path.sep,
+			"version": this.image.getVersion(),
+			"abi": this.image.getArch(),
+			"apiVersion": this.image.getApiVersion(),
+			"path": this.image.getImageManager().getOptions().path.resolve(this.image.getImageManager().getOptions().deployedPath, this.options.name ?? ""),
+			"showVersion": `${this.image.getTargetOS()} ${this.image.getTargetVersion()}(${this.image.getApiVersion()})`,
+			"harmonyOSVersion": `${this.image.getTargetOS()}-${this.image.getTargetVersion()}`,
+			"hw.apiName": this.image.getTargetVersion(),
+			"harmonyos.sdk.path": this.image.getImageManager().getOptions().imageBasePath,
+			"harmonyos.config.path": this.image.getImageManager().getOptions().configPath,
+			"harmonyos.log.path": this.image.getImageManager().getOptions().logPath,
+			"type": this.image.getSnakecaseDeviceType(),
+			"devModel": await this.getDevModel()
+		};
+	}
+	async buildIni() {
+		const config = await this.buildList();
+		const productConfigItem = (await this.image.getProductConfig()).find((item) => item.name === this.config.productName);
+		if (!productConfigItem) throw new Error(`Product config item ${this.config.productName} not found`);
+		return {
+			"name": config.name,
+			"hw.lcd.density": config.density,
+			"hw.lcd.height": productConfigItem.screenHeight,
+			"hw.lcd.width": productConfigItem.screenWidth,
+			"hw.cpu.ncore": config.cpuNumber,
+			"hw.phy.height": productConfigItem.outerScreenHeight,
+			"hw.phy.width": productConfigItem.outerScreenWidth,
+			"hw.cover.height": productConfigItem.outerScreenHeight,
+			"hw.cover.width": productConfigItem.outerScreenWidth,
+			"coverDiagonalSize": config.coverDiagonalSize ?? productConfigItem.outerScreenDiagonal,
+			"diagonalSize": config.diagonalSize,
+			"hw.ramSize": config.memoryRamSize,
+			"deviceType": config.type,
+			"uuid": config.uuid,
+			"hmApiVersion": config.apiVersion,
+			"hmAbi": config.abi,
+			"hmVersion": config.version,
+			"hw.cpu.arch": config.abi,
+			"hw.apiName": config["hw.apiName"],
+			"image.sysdir.1": config.imageDir,
+			"hvd.path": config.path,
+			"disk.dataPartition.size": `${config.dataDiskSize}M`,
+			"hmShowVersion": config.showVersion,
+			"harmonyOSVersion": config.harmonyOSVersion,
+			"harmonyos.sdk.path": config["harmonyos.sdk.path"],
+			"harmonyos.config.path": config["harmonyos.config.path"],
+			"harmonyos.log.path": config["harmonyos.log.path"],
+			"guest.version": config.version,
+			"devModel": config.devModel,
+			"model": config.model,
+			"isDefault": this.isDefault ? "true" : "false",
+			"isCustomize": this.isCustomize ? "true" : "false",
+			"isPublic": this.isPublic ? "true" : "false",
+			"vendorCountry": this.vendorCountry,
+			"hw.hdc.port": this.hwHdcPort.toString()
+		};
+	}
+	async toIniString() {
+		return `${Object.entries(await this.buildIni()).filter(([, value]) => value !== void 0 && value !== null).map(([key, value]) => `${key}=${value}`).join("\n")}\n`;
+	}
+	writeLists(config) {
+		const fs = this.image.getImageManager().getOptions().fs;
+		const listsPath = this.image.getImageManager().getOptions().path.resolve(this.image.getImageManager().getOptions().deployedPath, "lists.json");
+		if (!fs.existsSync(listsPath)) fs.writeFileSync(listsPath, JSON.stringify([config], null, 2));
+		else {
+			const lists = JSON.parse(fs.readFileSync(listsPath, "utf-8")) ?? [];
+			if (!Array.isArray(lists)) return /* @__PURE__ */ new Error("Lists is not an array");
+			if (lists.find((item) => item.name === config.name)) return;
+			lists.push(config);
+			fs.writeFileSync(listsPath, JSON.stringify(lists, null, 2));
+		}
+	}
+	async deploy(symlinkImage = true) {
+		const { fs, path, imageBasePath, sdkPath } = this.image.getImageManager().getOptions();
+		const config = await this.buildList();
+		if (fs.existsSync(config.path)) return /* @__PURE__ */ new Error(`Image ${config.name} already deployed`);
+		const error = this.writeLists(config);
+		if (error) return error;
+		fs.mkdirSync(config.path, { recursive: true });
+		fs.writeFileSync(path.join(config.path, "config.ini"), await this.toIniString());
+		const symlinkSdkPath = path.resolve(imageBasePath, "default", "openharmony");
+		if (!fs.existsSync(path.dirname(symlinkSdkPath))) fs.mkdirSync(path.dirname(symlinkSdkPath), { recursive: true });
+		try {
+			if (fs.lstatSync(symlinkSdkPath).isSymbolicLink()) fs.unlinkSync(symlinkSdkPath);
+			else return void 0;
+		} catch {}
+		fs.symlinkSync(sdkPath, symlinkSdkPath, "dir");
+		const systemImageDir = path.join(imageBasePath, "system-image");
+		if (symlinkImage && fs.existsSync(systemImageDir)) {
+			const linkPath = path.join(config.path, "system-image");
+			try {
+				const target = path.relative(config.path, systemImageDir);
+				fs.symlinkSync(target, linkPath);
+			} catch (err) {
+				return err instanceof Error ? err : new Error(String(err));
+			}
+		}
+	}
+};
+function createImageDeployer(image, uuid, name, config) {
+	return new ImageDeployerImpl(image, uuid, name, config);
+}
+
+//#endregion
+//#region src/image-downloader.ts
+var ImageDownloaderImpl = class {
+	emitter = mitt();
+	all = this.emitter.all;
+	on(type, handler) {
+		this.emitter.on(type, handler);
+	}
+	off(type, handler) {
+		this.emitter.off(type, handler);
+	}
+	emit(type, event) {
+		this.emitter.emit(type, event);
+	}
+	constructor(image, url) {
+		this.image = image;
+		this.url = url;
+	}
+	getImage() {
+		return this.image;
+	}
+	getUrl() {
+		return this.url;
+	}
+	getCacheFsPath() {
+		const { path, cachePath } = this.image.getImageManager().getOptions();
+		return path.resolve(cachePath, path.basename(this.url));
+	}
+	async makeRequest(signal, startByte = 0, retried416 = false) {
+		const { fs } = this.image.getImageManager().getOptions();
+		const cacheFsPath = this.getCacheFsPath();
+		const transformProgress = this.createProgressTransformer(startByte);
+		try {
+			return await axios.get(this.url, {
+				headers: startByte > 0 ? { Range: `bytes=${startByte}-` } : {},
+				responseType: "stream",
+				validateStatus: (status) => status === 200 || status === 206,
+				onDownloadProgress: (progress) => this.emit("download-progress", transformProgress(progress)),
+				signal
+			});
+		} catch (err) {
+			if (err instanceof AxiosError && err.response?.status === 416 && !retried416) {
+				if (fs.existsSync(cacheFsPath)) fs.rmSync(cacheFsPath, { force: true });
+				return this.makeRequest(signal, startByte, true);
+			}
+			throw err;
+		}
+	}
+	async startDownload(signal, retried416 = false) {
+		const { fs, cachePath } = this.image.getImageManager().getOptions();
+		const cacheFsPath = this.getCacheFsPath();
+		if (!fs.existsSync(cachePath)) fs.mkdirSync(cachePath, { recursive: true });
+		const startByte = fs.existsSync(cacheFsPath) ? fs.statSync(cacheFsPath).size : 0;
+		const response = await this.makeRequest(signal, startByte, retried416);
+		const isPartialContent = response.status === 206;
+		const start = startByte > 0 && isPartialContent ? startByte : 0;
+		const flags = start > 0 ? "a" : "w";
+		if (startByte > 0 && !isPartialContent) fs.rmSync(cacheFsPath, { force: true });
+		const writeStream = fs.createWriteStream(cacheFsPath, {
+			flags,
+			start
+		});
+		response.data.pipe(writeStream);
+		await new Promise((resolve, reject) => {
+			let settled = false;
+			const onError = (err) => {
+				if (settled) return;
+				settled = true;
+				response.data.destroy();
+				writeStream.destroy();
+				reject(err);
+			};
+			const onFinish = () => {
+				if (settled) return;
+				settled = true;
+				resolve();
+			};
+			response.data.on("error", onError);
+			writeStream.on("error", onError);
+			response.data.on("end", () => writeStream.end());
+			writeStream.on("finish", onFinish);
+		});
+	}
+	async checkChecksum(signal) {
+		const { crypto, fs } = this.image.getImageManager().getOptions();
+		const checksum = this.image.getChecksum();
+		const hash = crypto.createHash("sha256", { signal });
+		const stream = fs.createReadStream(this.getCacheFsPath(), { signal });
+		stream.on("data", (chunk) => hash.update(chunk));
+		await new Promise((resolve, reject) => stream.on("end", resolve).on("error", reject));
+		return hash.digest("hex") === checksum;
+	}
+	async extract(signal, symlinkOpenHarmonySdk = true) {
+		const { fs, path, imageBasePath, sdkPath } = this.image.getImageManager().getOptions();
+		const cacheFsPath = this.getCacheFsPath();
+		const stream = fs.createReadStream(cacheFsPath, { signal });
+		const progressStream = progress({ length: fs.statSync(cacheFsPath).size });
+		const extractStream = unzipper.Extract({ path: this.image.getFsPath() });
+		progressStream.on("progress", (progress) => this.emitter.emit("extract-progress", progress));
+		stream.pipe(progressStream).pipe(extractStream);
+		await extractStream.promise();
+		if (symlinkOpenHarmonySdk) {
+			const symlinkSdkPath = path.resolve(imageBasePath, "default", "openharmony");
+			if (!fs.existsSync(path.dirname(symlinkSdkPath))) fs.mkdirSync(path.dirname(symlinkSdkPath), { recursive: true });
+			if (!fs.existsSync(symlinkSdkPath)) fs.symlinkSync(sdkPath, symlinkSdkPath, "dir");
+		}
+	}
+	async clean() {
+		const { fs } = this.image.getImageManager().getOptions();
+		const cacheFsPath = this.getCacheFsPath();
+		if (fs.existsSync(cacheFsPath)) fs.rmSync(cacheFsPath, { recursive: true });
+	}
+	createProgressTransformer(startByte) {
+		let previousPercentage = 0;
+		const bytesPerKB = 1024;
+		const bytesPerMB = bytesPerKB * 1024;
+		return (progress) => {
+			const rangeTotal = progress.total ?? 0;
+			const rangeLoaded = progress.loaded ?? 0;
+			const total = startByte + rangeTotal;
+			const loaded = startByte + rangeLoaded;
+			const percentage = total > 0 ? loaded / total * 100 : 0;
+			const increment = Math.max(0, percentage - previousPercentage);
+			previousPercentage = percentage;
+			const rate = progress.rate ?? 0;
+			const unit = rate >= bytesPerMB ? "MB" : "KB";
+			const network = unit === "MB" ? rate / bytesPerMB : rate / bytesPerKB;
+			return {
+				...progress,
+				total,
+				loaded,
+				network,
+				unit,
+				increment
+			};
+		};
+	}
+};
+function createImageDownloader(image, url) {
+	return new ImageDownloaderImpl(image, url);
+}
+
+//#endregion
+//#region src/images/image.ts
+var ImageBase = class {
+	constructor(response, imageManager, resolvedFsPath) {
+		this.response = response;
+		this.imageManager = imageManager;
+		this.resolvedFsPath = resolvedFsPath;
+	}
+	getImageManager() {
+		return this.imageManager;
+	}
+	getArch() {
+		const [, , deviceTypeWithArch] = this.getPath()?.split(",") ?? [];
+		const split = deviceTypeWithArch?.split("_") ?? [];
+		return split[split.length - 1];
+	}
+	getPath() {
+		return this.response?.path;
+	}
+	getChecksum() {
+		return this.response?.archive?.complete?.checksum;
+	}
+	getFsPath() {
+		return this.resolvedFsPath;
+	}
+	async isDownloaded() {
+		return this.imageManager.getOptions().fs.existsSync(this.getFsPath()) && this.imageManager.getOptions().fs.statSync(this.getFsPath()).isDirectory();
+	}
+	getVersion() {
+		return this.response?.version;
+	}
+	getApiVersion() {
+		return this.response?.apiVersion;
+	}
+	getTargetOS() {
+		const [, systemNameWithVersion] = this.getPath()?.split(",") ?? [];
+		const [systemName] = systemNameWithVersion?.split("-") ?? [];
+		return systemName ?? "";
+	}
+	getTargetVersion() {
+		const [, systemNameWithVersion] = this.getPath()?.split(",") ?? [];
+		const [, version] = systemNameWithVersion?.split("-") ?? [];
+		return version ?? "";
+	}
+	getDeviceType() {
+		const [, , deviceTypeWithArch] = this.getPath()?.split(",") ?? [];
+		const [deviceType] = deviceTypeWithArch?.split("_") ?? [];
+		return deviceType ?? "";
+	}
+	getSnakecaseDeviceType() {
+		const deviceType = this.getDeviceType();
+		if (deviceType === "pc") return "2in1_foldable";
+		return deviceType.toLowerCase();
+	}
+	async createDownloader() {
+		const url = await this.getUrl();
+		if (url instanceof RequestUrlError) return url;
+		return createImageDownloader(this, url);
+	}
+	async getUrl() {
+		try {
+			const response = await axios.post("https://devecostudio-drcn.deveco.dbankcloud.com/sdkmanager/v7/hos/download", {
+				osArch: this.imageManager.getArch(),
+				osType: this.imageManager.getOS(),
+				path: {
+					path: this.getPath(),
+					version: this.getVersion()
+				},
+				imei: "d490a470-8719-4baf-9cc4-9c78d40d"
+			});
+			if (typeof response.data?.url !== "string") return new RequestUrlError(response.data?.body, response.data?.code);
+			return response.data.url;
+		} catch (error) {
+			return new RequestUrlError(error.message, error.code, error);
+		}
+	}
+};
+
+//#endregion
+//#region src/images/local-image.ts
+var LocalImageImpl = class extends ImageBase {
+	imageType = "local";
+	createDeployer(name, config) {
+		return createImageDeployer(this, this.getImageManager().getOptions().crypto.randomUUID(), name, config);
+	}
+	async getProductConfig(usingDefaultProductConfig = false) {
+		const productConfig = usingDefaultProductConfig ? (await import("./default-product-config.mjs")).default : await this.getImageManager().getProductConfig();
+		const deviceType = this.getDeviceType().toLowerCase();
+		if (!deviceType) return [];
+		if (deviceType === "pc") return productConfig["2in1 Foldable"] ?? [];
+		const key = Object.keys(productConfig).find((key) => key.toLowerCase() === deviceType);
+		if (key) return productConfig[key] ?? [];
+		return [];
+	}
+	async delete() {
+		const fs = this.getImageManager().getOptions().fs;
+		const path = this.getFsPath();
+		if (!fs.existsSync(path) || !fs.statSync(path).isDirectory()) return /* @__PURE__ */ new Error("Image path does not exist");
+		fs.rmSync(path, { recursive: true });
+	}
+	getExecutablePath() {
+		const { emulatorPath, process, path } = this.getImageManager().getOptions();
+		return process.platform === "win32" ? path.join(emulatorPath, "Emulator.exe") : path.join(emulatorPath, "Emulator");
+	}
+	async buildStartCommand(deployer) {
+		const config = await deployer.buildList();
+		return `${this.getExecutablePath()} ${[
+			"-hvd",
+			`"${config.name.replace(/"/g, "\\\"")}"`,
+			"-path",
+			`"${this.getImageManager().getOptions().deployedPath.replace(/"/g, "\\\"")}"`,
+			"-imageRoot",
+			`"${config.path.replace(/"/g, "\\\"")}"`
+		].join(" ")}`;
+	}
+	async start(deployer) {
+		const { child_process, emulatorPath } = this.getImageManager().getOptions();
+		return child_process.exec(await this.buildStartCommand(deployer), { cwd: emulatorPath });
+	}
+	async buildStopCommand(deployer) {
+		const config = await deployer.buildList();
+		return `${this.getExecutablePath()} ${["-stop", `"${config.name.replace(/"/g, "\\\"")}"`].join(" ")}`;
+	}
+	async stop(deployer) {
+		const { child_process, emulatorPath } = this.getImageManager().getOptions();
+		return child_process.exec(await this.buildStopCommand(deployer), { cwd: emulatorPath });
+	}
+	toJSON() {
+		return {
+			imageType: this.imageType,
+			path: this.getPath(),
+			version: this.getVersion(),
+			apiVersion: this.getApiVersion(),
+			targetVersion: this.getTargetVersion(),
+			checksum: this.getChecksum()
+		};
+	}
+};
+
+//#endregion
+//#region src/images/remote-image.ts
+var RemoteImageImpl = class extends ImageBase {
+	imageType = "remote";
+	toJSON() {
+		return {
+			imageType: this.imageType,
+			path: this.getPath(),
+			apiVersion: this.getApiVersion(),
+			checksum: this.getChecksum()
+		};
+	}
+};
+
+//#endregion
+//#region src/options.ts
+async function resolveImageManagerOptions(options) {
+	const os = options.os ?? await import("node:os");
+	const path = options.path ?? await import("node:path");
+	const process = options.process ?? await import("node:process");
+	function resolveDefaultImageBasePath() {
+		switch (process.platform) {
+			case "win32": return typeof process.env.APPDATA === "string" && process.env.APPDATA.length > 0 ? path.resolve(process.env.APPDATA, "Local", "Huawei", "Sdk") : path.resolve(os.homedir(), "AppData", "Local", "Huawei", "Sdk");
+			case "darwin": return path.resolve(os.homedir(), "Library", "Huawei", "Sdk");
+			default: return path.resolve(os.homedir(), ".huawei", "Sdk");
+		}
+	}
+	function resolveDefaultDeployedPath() {
+		switch (process.platform) {
+			case "win32": return typeof process.env.APPDATA === "string" && process.env.APPDATA.length > 0 ? path.resolve(process.env.APPDATA, "Local", "Huawei", "Emulator", "deployed") : path.resolve(os.homedir(), "AppData", "Local", "Huawei", "Emulator", "deployed");
+			default: return path.resolve(os.homedir(), ".huawei", "Emulator", "deployed");
+		}
+	}
+	function resolveDefaultSdkPath() {
+		switch (process.platform) {
+			case "darwin": return "/Applications/DevEco-Studio.app/Contents/sdk/default/openharmony";
+			case "win32": return "C:\\Program Files\\Huawei\\DevEco Studio\\sdk\\default\\openharmony";
+			default: return path.resolve(os.homedir(), ".huawei", "Sdk", "default", "openharmony");
+		}
+	}
+	function resolveDefaultConfigPath() {
+		switch (process.platform) {
+			case "darwin": return path.resolve(os.homedir(), "Library", "Application Support", "Huawei", "DevEcoStudio6.0");
+			case "win32": return path.resolve(process.env.APPDATA ?? os.homedir(), "Roaming", "Huawei", "DevEcoStudio6.0");
+			default: return path.resolve(os.homedir(), ".huawei", "DevEcoStudio6.0");
+		}
+	}
+	function resolveDefaultLogPath() {
+		switch (process.platform) {
+			case "darwin": return path.resolve(os.homedir(), "Library", "Logs", "Huawei", "DevEcoStudio6.0");
+			case "win32": return path.resolve(process.env.APPDATA ?? os.homedir(), "Local", "Huawei", "DevEcoStudio6.0", "log");
+			default: return path.resolve(os.homedir(), ".huawei", "DevEcoStudio6.0", "log");
+		}
+	}
+	function resolveDefaultEmulatorPath() {
+		switch (process.platform) {
+			case "darwin": return "/Applications/DevEco-Studio.app/Contents/tools/emulator/Emulator";
+			case "win32": return path.resolve("C:", "Program Files", "Huawei", "DevEco Studio", "tools", "emulator", "Emulator.exe");
+			default: return path.resolve(os.homedir(), ".huawei", "Emulator");
+		}
+	}
+	const imageBasePath = options.imageBasePath ?? resolveDefaultImageBasePath();
+	const cachePath = options.cachePath ?? path.resolve(imageBasePath, "cache");
+	return {
+		imageBasePath,
+		deployedPath: options.deployedPath ?? resolveDefaultDeployedPath(),
+		cachePath,
+		sdkPath: options.sdkPath ?? resolveDefaultSdkPath(),
+		configPath: options.configPath ?? resolveDefaultConfigPath(),
+		logPath: options.logPath ?? resolveDefaultLogPath(),
+		emulatorPath: options.emulatorPath ?? resolveDefaultEmulatorPath(),
+		path,
+		os,
+		fs: options.fs ?? await import("node:fs"),
+		process: options.process ?? await import("node:process"),
+		crypto: options.crypto ?? await import("node:crypto"),
+		child_process: options.child_process ?? await import("node:child_process")
+	};
+}
+
+//#endregion
+//#region src/image-manager.ts
+var ImageManagerImpl = class {
+	constructor(resolvedOptions) {
+		this.resolvedOptions = resolvedOptions;
+	}
+	getOptions() {
+		return this.resolvedOptions;
+	}
+	getOS() {
+		switch (this.resolvedOptions.process.platform) {
+			case "win32": return "windows";
+			case "darwin": return "mac";
+			default: return "linux";
+		}
+	}
+	getArch() {
+		if (this.resolvedOptions.process.arch.toLowerCase().includes("arm")) return "arm64";
+		return "x86";
+	}
+	async getImages() {
+		const response = await axios.post("https://devecostudio-drcn.deveco.dbankcloud.com/sdkmanager/v8/hos/getSdkList", {
+			osArch: this.getArch(),
+			osType: this.getOS(),
+			supportVersion: "6.0-hos-single-8"
+		});
+		if (!Array.isArray(response.data)) return [];
+		const images = [];
+		for (const responseItem of response.data) {
+			const resolvedFsPath = this.resolvedOptions.path.resolve(this.resolvedOptions.imageBasePath, ...responseItem.path.split(","));
+			if (this.resolvedOptions.fs.existsSync(resolvedFsPath) && this.resolvedOptions.fs.statSync(resolvedFsPath).isDirectory()) images.push(new LocalImageImpl(responseItem, this, resolvedFsPath));
+			else images.push(new RemoteImageImpl(responseItem, this, resolvedFsPath));
+		}
+		return images;
+	}
+	async getProductConfig() {
+		const productConfigPath = this.resolvedOptions.path.resolve(this.resolvedOptions.imageBasePath, "productConfig.json");
+		if (!this.resolvedOptions.fs.existsSync(productConfigPath) || !this.resolvedOptions.fs.statSync(productConfigPath).isFile()) return (await import("./default-product-config.mjs")).default;
+		return JSON.parse(this.resolvedOptions.fs.readFileSync(productConfigPath, "utf-8"));
+	}
+	async writeDefaultProductConfig(existSkip = false) {
+		const productConfigPath = this.resolvedOptions.path.resolve(this.resolvedOptions.imageBasePath, "productConfig.json");
+		if (existSkip && this.resolvedOptions.fs.existsSync(productConfigPath)) return;
+		this.resolvedOptions.fs.writeFileSync(productConfigPath, JSON.stringify((await import("./default-product-config.mjs")).default, null, 2));
+	}
+};
+async function createImageManager(options = {}) {
+	return new ImageManagerImpl(await resolveImageManagerOptions(options));
+}
+
+//#endregion
+export { DevModel, RequestUrlError, createImageManager };