@hot-updater/apple-helper 0.25.4

package/dist/index.js

@@ -0,0 +1,816 @@
+import { BuildLogger, colors, getCwd, getReactNativeMetadatas, p } from "@hot-updater/cli-tools";
+import fs from "fs";
+import path from "path";
+import { generateMinBundleId } from "@hot-updater/plugin-core";
+import { ExecaError, execa } from "execa";
+import { mkdtemp } from "node:fs/promises";
+import os, { tmpdir } from "node:os";
+import { join } from "node:path";
+
+//#region src/utils/cocoapods.ts
+const installPodsIfNeeded = async (sourceDir) => {
+	const podfilePath = path.join(sourceDir, "Podfile");
+	if (!fs.existsSync(podfilePath)) {
+		p.log.info("No Podfile found, skipping CocoaPods installation");
+		return;
+	}
+	const gemfilePaths = [path.join(sourceDir, "Gemfile"), path.join(getCwd(), "Gemfile")];
+	const shouldUseBundler = (await Promise.all(gemfilePaths.map(checkShouldUseBundler))).some(Boolean);
+	try {
+		if (shouldUseBundler) {
+			p.log.info("Using bundler for CocoaPods installation");
+			const bundleSpinner = p.spinner();
+			bundleSpinner.start("Installing Ruby gems");
+			await execa("bundle", ["install"], { cwd: sourceDir });
+			bundleSpinner.stop("Ruby gems installed");
+			const podSpinner = p.spinner();
+			podSpinner.start("Installing CocoaPods dependencies");
+			await execa("bundle", [
+				"exec",
+				"pod",
+				"install"
+			], {
+				cwd: sourceDir,
+				env: preparePodInstallEnvVars()
+			});
+			podSpinner.stop("CocoaPods dependencies installed");
+		} else {
+			const spinner = p.spinner();
+			spinner.start("Installing CocoaPods dependencies");
+			await execa("pod", ["install"], {
+				cwd: sourceDir,
+				env: preparePodInstallEnvVars()
+			});
+			spinner.stop("CocoaPods dependencies installed");
+		}
+	} catch (error) {
+		throw new Error(`pod install failed: ${error}`);
+	}
+};
+const checkShouldUseBundler = async (gemfilePath) => {
+	try {
+		if (!fs.existsSync(gemfilePath)) return false;
+		return (await fs.promises.readFile(gemfilePath, "utf-8")).includes("cocoapods");
+	} catch (_error) {
+		return false;
+	}
+};
+const preparePodInstallEnvVars = () => {
+	const { minor } = getReactNativeMetadatas().version;
+	const usePrebuiltReactNative = minor >= 81;
+	return {
+		RCT_IGNORE_PODS_DEPRECATION: "1",
+		RCT_USE_RN_DEP: process.env["RCT_USE_RN_DEP"] !== void 0 ? String(process.env["RCT_USE_RN_DEP"]) : usePrebuiltReactNative ? "1" : "0",
+		RCT_USE_PREBUILT_RNCORE: process.env["RCT_USE_PREBUILT_RNCORE"] !== void 0 ? String(process.env["RCT_USE_PREBUILT_RNCORE"]) : usePrebuiltReactNative ? "1" : "0"
+	};
+};
+
+//#endregion
+//#region src/utils/createRandomTmpDir.ts
+const createRandomTmpDir = async (prefix = "apple-helper-") => {
+	return await mkdtemp(join(tmpdir(), prefix));
+};
+
+//#endregion
+//#region src/utils/createXcodebuildLogger.ts
+const createXcodebuildLogger = () => new BuildLogger({
+	failurePatterns: ["BUILD FAILED", "ARCHIVE FAILED"],
+	importantLogPatterns: [
+		"error:",
+		"** BUILD FAILED **",
+		"** ARCHIVE FAILED **",
+		"The following build commands failed:"
+	],
+	progressMapping: [
+		[["[CP-User] [RN]Check rncore"], 10],
+		[["[CP-User] [Hermes] Replace Hermes"], 35],
+		[["[CP-User] [RN]Check FBReactNativeSpec"], 53],
+		[["React-FabricComponents"], 66],
+		[["[CP] Check Pods Manifest.lock"], 90],
+		[["BUILD SUCCEEDED", "ARCHIVE SUCCEEDED"], 100]
+	]
+});
+
+//#endregion
+//#region src/utils/platform.ts
+/**
+* Platform configurations for different Apple platforms
+*/
+const platformConfigs = { ios: {
+	name: "ios",
+	deviceSdk: "iphoneos",
+	simulatorSdk: "iphonesimulator",
+	supportsSimulator: true,
+	deviceDestination: "platform=iOS",
+	simulatorDestination: "platform=iOS Simulator"
+} };
+
+//#endregion
+//#region src/utils/destination.ts
+const buildDestinationString = ({ deviceType, platform, useGeneric }) => `${useGeneric ? "generic/" : ""}${deviceType === "device" ? platformConfigs[platform].deviceDestination : platformConfigs[platform].simulatorDestination}`;
+/**
+* Resolves IosBuildDestination to xcodebuild destination format
+*/
+const resolveDestination = ({ destination, useGeneric }) => {
+	if (typeof destination === "object") {
+		if ("id" in destination) return `id=${destination.id}`;
+		if ("name" in destination) return `name=${destination.name}`;
+	}
+	switch (destination) {
+		case "ios-device": return buildDestinationString({
+			platform: "ios",
+			deviceType: "device",
+			useGeneric
+		});
+		case "ios-simulator": return buildDestinationString({
+			platform: "ios",
+			deviceType: "simulator",
+			useGeneric
+		});
+	}
+};
+const resolveDestinations = ({ destinations, useGeneric }) => {
+	return destinations.map((destination) => resolveDestination({
+		destination,
+		useGeneric
+	}));
+};
+const getDefaultDestination = ({ platform, useGeneric, deviceType }) => {
+	return buildDestinationString({
+		deviceType,
+		platform,
+		useGeneric
+	});
+};
+
+//#endregion
+//#region src/utils/parseXcodeProjectInfo.ts
+const parseXcodeProjectInfo = async (sourceDir) => {
+	const files = await fs.promises.readdir(sourceDir);
+	const workspace = files.find((file) => file.endsWith(".xcworkspace"));
+	if (workspace) return {
+		isWorkspace: true,
+		name: workspace,
+		path: path.join(sourceDir, workspace)
+	};
+	const project = files.find((file) => file.endsWith(".xcodeproj"));
+	if (project) return {
+		isWorkspace: false,
+		name: project,
+		path: path.join(sourceDir, project)
+	};
+	throw new Error(`No Xcode project or workspace found in ${sourceDir}`);
+};
+
+//#endregion
+//#region src/utils/prettifyXcodebuildError.ts
+const prettifyXcodebuildError = (error) => {
+	let errorString = "";
+	if (error instanceof ExecaError || error instanceof Error || "message" in error) errorString = error.message;
+	if (errorString.includes("error: No profiles for") || errorString.includes("error: Provisioning profile")) return /* @__PURE__ */ new Error("Xcodebuild failed: Not valid provisioning profile is set in the project. Check out Singing & Capabilities tab in the Xcode.");
+	return /* @__PURE__ */ new Error(`Xcodebuild failed: ${error}`);
+};
+
+//#endregion
+//#region src/builder/archiveXcodeProject.ts
+const archiveXcodeProject = async ({ sourceDir, platform, schemeConfig }) => {
+	const xcodeProject = await parseXcodeProjectInfo(sourceDir);
+	if (schemeConfig.installPods ?? true) await installPodsIfNeeded(sourceDir);
+	const tmpDir = await createRandomTmpDir();
+	const archiveName = `${xcodeProject.name.replace(".xcworkspace", "").replace(".xcodeproj", "")}.xcarchive`;
+	const archivePath = path.join(tmpDir, archiveName);
+	const archiveArgs = prepareArchiveArgs({
+		archivePath,
+		platform,
+		schemeConfig,
+		sourceDir,
+		xcodeProject
+	});
+	p.log.info(`Xcode Archive Settings:
+Project    ${xcodeProject.name}
+Scheme     ${schemeConfig.scheme}
+Platform   ${platform}
+Command    xcodebuild ${archiveArgs.join(" ")}
+`);
+	const logger = createXcodebuildLogger();
+	logger.start(`${xcodeProject.name} (Archive)`);
+	try {
+		const process$1 = execa("xcodebuild", archiveArgs, { cwd: sourceDir });
+		for await (const line of process$1) logger.processLine(line);
+		logger.stop("Archive completed successfully");
+		return { archivePath };
+	} catch (error) {
+		logger.stop("Archive failed", false);
+		throw prettifyXcodebuildError(error);
+	}
+};
+const prepareArchiveArgs = ({ archivePath, platform, schemeConfig, sourceDir, xcodeProject }) => {
+	const args = [
+		xcodeProject.isWorkspace ? "-workspace" : "-project",
+		path.join(sourceDir, xcodeProject.name),
+		"-scheme",
+		schemeConfig.scheme,
+		"-configuration",
+		schemeConfig.configuration || "Release",
+		"archive",
+		"-archivePath",
+		archivePath,
+		`HOT_UPDATER_MIN_BUNDLE_ID=${generateMinBundleId()}`
+	];
+	if (schemeConfig.xcconfig) args.push("-xcconfig", schemeConfig.xcconfig);
+	if (schemeConfig.extraParams) args.push(...schemeConfig.extraParams);
+	const resolvedDestinations = resolveDestinations({
+		destinations: schemeConfig.destination || [],
+		useGeneric: true
+	});
+	if (resolvedDestinations.length === 0) resolvedDestinations.push(getDefaultDestination({
+		deviceType: "device",
+		platform,
+		useGeneric: true
+	}));
+	for (const destination of resolvedDestinations) args.push("-destination", destination);
+	return args;
+};
+
+//#endregion
+//#region src/builder/exportXcodeArchive.ts
+const exportXcodeArchive = async ({ archivePath, sourceDir, exportExtraParams, exportOptionsPlist }) => {
+	const exportPath = await createRandomTmpDir();
+	const exportArgs = prepareExportArgs({
+		archivePath,
+		exportPath,
+		exportOptionsPlist,
+		exportExtraParams
+	});
+	const spinner = p.spinner();
+	spinner.start("Exporting archive to IPA");
+	try {
+		await execa("xcodebuild", exportArgs, { cwd: sourceDir });
+		spinner.stop("Archive exported successfully");
+		return { exportPath };
+	} catch (error) {
+		spinner.stop("Export failed");
+		throw prettifyXcodebuildError(error);
+	}
+};
+const prepareExportArgs = ({ exportPath, archivePath, exportExtraParams, exportOptionsPlist }) => {
+	const args = [
+		"-exportArchive",
+		"-archivePath",
+		archivePath,
+		"-exportPath",
+		exportPath
+	];
+	if (exportExtraParams) args.push(...exportExtraParams);
+	args.push("-exportOptionsPlist", exportOptionsPlist);
+	return args;
+};
+
+//#endregion
+//#region src/utils/assertXcodebuildExist.ts
+const assertXcodebuildExist = async () => {
+	try {
+		await execa("which", ["xcodebuild"]);
+	} catch {
+		p.log.error(`${colors.blueBright("xcodebuild")} resolve failed. Ensure that xcode is installed on your machine or xcodebuild is included in your path`);
+		process.exit(1);
+	}
+};
+
+//#endregion
+//#region src/utils/enrichNativeBuildIosScheme.ts
+const resolveExportOptionsPlist = (exportOptionsPlist) => {
+	const resolvedExportOptionsPlist = exportOptionsPlist ? path.isAbsolute(exportOptionsPlist) ? exportOptionsPlist : path.resolve(getCwd(), exportOptionsPlist) : void 0;
+	if (resolvedExportOptionsPlist && !fs.existsSync(resolvedExportOptionsPlist)) {
+		p.log.error(`exportOptionsPlist doesn't exist in ${resolvedExportOptionsPlist}`);
+		process.exit(1);
+	}
+	return resolvedExportOptionsPlist;
+};
+const enrichNativeBuildIosScheme = async (scheme) => {
+	return {
+		platform: "ios",
+		installPods: true,
+		configuration: "Release",
+		destination: [],
+		...scheme,
+		exportOptionsPlist: resolveExportOptionsPlist(scheme.exportOptionsPlist)
+	};
+};
+
+//#endregion
+//#region src/buildIos.ts
+const buildIos = async ({ schemeConfig: _schemeConfig }) => {
+	await assertXcodebuildExist();
+	const iosProjectRoot = path.join(getCwd(), "ios");
+	const schemeConfig = await enrichNativeBuildIosScheme(_schemeConfig);
+	const buildDirectory = await createRandomTmpDir();
+	const archiveDir = path.join(buildDirectory, "archive");
+	const exportDir = path.join(buildDirectory, "export");
+	await fs.promises.mkdir(archiveDir, { recursive: true });
+	const { archivePath } = await archiveXcodeProject({
+		platform: schemeConfig.platform,
+		schemeConfig,
+		sourceDir: iosProjectRoot
+	});
+	const finalArchivePath = path.join(archiveDir, path.basename(archivePath));
+	await fs.promises.cp(archivePath, finalArchivePath, { recursive: true });
+	const appFromArchive = extractAppFromXcarchive(finalArchivePath);
+	if (appFromArchive) {
+		await fs.promises.cp(appFromArchive, path.join(archiveDir, path.basename(appFromArchive)), { recursive: true });
+		p.log.success(".app extracted from .xcarchive");
+	}
+	if (schemeConfig.exportOptionsPlist) {
+		await fs.promises.mkdir(exportDir, { recursive: true });
+		const { exportPath } = await exportXcodeArchive({
+			archivePath,
+			exportExtraParams: schemeConfig.exportExtraParams,
+			exportOptionsPlist: schemeConfig.exportOptionsPlist,
+			sourceDir: iosProjectRoot
+		});
+		await fs.promises.cp(exportPath, exportDir, { recursive: true });
+		const ipaFile = fs.readdirSync(exportDir).find((file) => file.endsWith(".ipa"));
+		if (ipaFile) return {
+			buildDirectory,
+			buildArtifactPath: path.join(exportDir, ipaFile)
+		};
+		throw new Error("IPA file not found after export");
+	}
+	return {
+		buildDirectory,
+		buildArtifactPath: finalArchivePath
+	};
+};
+const extractAppFromXcarchive = (archivePath) => {
+	const productsPath = path.join(archivePath, "Products", "Applications");
+	if (!fs.existsSync(productsPath)) return;
+	const appFile = fs.readdirSync(productsPath).find((file) => file.endsWith(".app"));
+	if (appFile) return path.join(productsPath, appFile);
+	p.log.warn("Failed to extract .app from xcarchive");
+};
+
+//#endregion
+//#region src/builder/buildXcodeProject.ts
+const buildXcodeProject = async ({ sourceDir, platform, scheme, configuration, deviceType, udid, installPods, extraParams }) => {
+	const xcodeProject = await parseXcodeProjectInfo(sourceDir);
+	if (installPods ?? true) await installPodsIfNeeded(sourceDir);
+	const derivedDataPath = await createRandomTmpDir();
+	const buildArgs = prepareBuildArgs({
+		configuration,
+		derivedDataPath,
+		deviceType,
+		extraParams,
+		platform,
+		scheme,
+		sourceDir,
+		udid,
+		xcodeProject
+	});
+	p.log.info(`Xcode Build Settings:
+Project        ${xcodeProject.name}
+Scheme         ${scheme}
+Configuration  ${configuration}
+Platform       ${platform}
+Device Type    ${deviceType}
+Command        xcodebuild ${buildArgs.join(" ")}
+`);
+	const logger = createXcodebuildLogger();
+	logger.start(`${xcodeProject.name} (Build)`);
+	try {
+		const process$1 = execa("xcodebuild", buildArgs, { cwd: sourceDir });
+		for await (const line of process$1) logger.processLine(line);
+		logger.stop("Build completed successfully");
+		return await getBuildSettings({
+			configuration,
+			derivedDataPath,
+			deviceType,
+			platform,
+			scheme,
+			sourceDir,
+			udid,
+			xcodeProject
+		});
+	} catch (error) {
+		logger.stop("Build failed", false);
+		throw prettifyXcodebuildError(error);
+	}
+};
+const prepareBuildArgs = ({ xcodeProject, sourceDir, platform, scheme, configuration, deviceType, udid, derivedDataPath, extraParams }) => {
+	const sdk = deviceType === "simulator" ? platformConfigs[platform].simulatorSdk : platformConfigs[platform].deviceSdk;
+	const destination = udid ? `id=${udid}` : deviceType === "simulator" ? platformConfigs[platform].simulatorDestination : platformConfigs[platform].deviceDestination;
+	const args = [
+		xcodeProject.isWorkspace ? "-workspace" : "-project",
+		path.join(sourceDir, xcodeProject.name),
+		"-scheme",
+		scheme,
+		"-configuration",
+		configuration,
+		"-sdk",
+		sdk,
+		"-destination",
+		destination,
+		"-derivedDataPath",
+		derivedDataPath,
+		`HOT_UPDATER_MIN_BUNDLE_ID=${generateMinBundleId()}`,
+		"build"
+	];
+	if (extraParams) args.push(...extraParams);
+	return args;
+};
+const getBuildSettings = async ({ xcodeProject, sourceDir, platform, scheme, configuration, deviceType, udid, derivedDataPath }) => {
+	const sdk = deviceType === "simulator" ? platformConfigs[platform].simulatorSdk : platformConfigs[platform].deviceSdk;
+	const destination = udid ? `id=${udid}` : deviceType === "simulator" ? platformConfigs[platform].simulatorDestination : platformConfigs[platform].deviceDestination;
+	const { stdout: buildSettings } = await execa("xcodebuild", [
+		xcodeProject.isWorkspace ? "-workspace" : "-project",
+		xcodeProject.name,
+		"-scheme",
+		scheme,
+		"-configuration",
+		configuration,
+		"-sdk",
+		sdk,
+		"-destination",
+		destination,
+		"-derivedDataPath",
+		derivedDataPath,
+		"-showBuildSettings",
+		"-json"
+	], { cwd: sourceDir });
+	const settings = JSON.parse(buildSettings).filter(({ target }) => target !== "React" && target !== "React-Core");
+	if (settings.length === 0) throw new Error("Failed to get build settings for your project");
+	const targetSettings = settings[0].buildSettings;
+	const wrapperExtension = targetSettings.WRAPPER_EXTENSION;
+	if (wrapperExtension !== "app" && wrapperExtension !== "framework") throw new Error(`Expected wrapper extension to be "app" or "framework" but found: ${wrapperExtension}`);
+	const targetBuildDir = targetSettings.TARGET_BUILD_DIR;
+	const executableFolderPath = targetSettings.EXECUTABLE_FOLDER_PATH;
+	const fullProductName = targetSettings.FULL_PRODUCT_NAME;
+	const infoPlistPath = targetSettings.INFOPLIST_PATH;
+	if (!targetBuildDir || !executableFolderPath || !fullProductName) throw new Error("Failed to get build paths from build settings");
+	return {
+		appPath: path.join(targetBuildDir, executableFolderPath),
+		infoPlistPath: path.join(targetBuildDir, infoPlistPath)
+	};
+};
+
+//#endregion
+//#region src/runner/deviceRunner.ts
+const installAndLaunchOnDevice = async ({ device, appPath, options }) => {
+	await installOnDevice({
+		device,
+		appPath,
+		options
+	});
+	if (options.launch !== false) await launchAppOnDevice({
+		device,
+		options
+	});
+};
+const installOnDevice = async ({ device, appPath, options }) => {
+	const deviceCtlArgs = [
+		"devicectl",
+		"device",
+		"install",
+		"app",
+		"--device",
+		device.udid,
+		appPath
+	];
+	const spinner = p.spinner();
+	spinner.start(`Installing app on ${device.name}`);
+	try {
+		await execa("xcrun", deviceCtlArgs, { cwd: options.sourceDir });
+		spinner.stop(`Successfully installed app on ${device.name}`);
+	} catch (error) {
+		spinner.stop(`Failed to install app on ${device.name}`);
+		throw new Error(`Failed to install the app on ${device.name}: ${error}`);
+	}
+};
+const launchAppOnDevice = async ({ device, options }) => {
+	const deviceCtlArgs = [
+		"devicectl",
+		"device",
+		"process",
+		"launch",
+		"--device",
+		device.udid,
+		options.bundleIdentifier
+	];
+	const spinner = p.spinner();
+	spinner.start(`Launching app on ${device.name}`);
+	try {
+		await execa("xcrun", deviceCtlArgs, { cwd: options.sourceDir });
+		spinner.stop(`Successfully launched app on ${device.name}`);
+	} catch (error) {
+		spinner.stop(`Failed to launch app on ${device.name}`);
+		throw new Error(`Failed to launch the app on ${device.name}: ${error}`);
+	}
+};
+
+//#endregion
+//#region src/runner/simulatorRunner.ts
+const installAndLaunchOnSimulator = async ({ device, appPath, options }) => {
+	await launchSimulator({ device });
+	await installOnSimulator({
+		device,
+		appPath,
+		options
+	});
+	if (options.launch !== false) await launchAppOnSimulator({
+		device,
+		options
+	});
+};
+const launchSimulator = async ({ device }) => {
+	if (device.type !== "simulator") return;
+	const { stdout: activeDeveloperDir } = await execa("xcode-select", ["-p"]);
+	await execa("open", [
+		`${activeDeveloperDir}/Applications/Simulator.app`,
+		"--args",
+		"-CurrentDeviceUDID",
+		device.udid
+	]);
+	if (device.state !== "Booted") await bootSimulator({ device });
+};
+const installOnSimulator = async ({ device, appPath, options }) => {
+	const spinner = p.spinner();
+	spinner.start(`Installing app on "${device.name}"`);
+	try {
+		await execa("xcrun", [
+			"simctl",
+			"install",
+			device.udid,
+			appPath
+		], { cwd: options.sourceDir });
+		spinner.stop(`Successfully installed app on "${device.name}"`);
+	} catch (error) {
+		spinner.stop(`Failed to install app on "${device.name}"`);
+		throw new Error(`Failed to install the app on simulator: ${error}`);
+	}
+};
+const launchAppOnSimulator = async ({ device, options }) => {
+	const spinner = p.spinner();
+	spinner.start(`Launching app on "${device.name}"`);
+	try {
+		await execa("xcrun", [
+			"simctl",
+			"launch",
+			device.udid,
+			options.bundleIdentifier
+		], { cwd: options.sourceDir });
+		spinner.stop(`Successfully launched app on "${device.name}"`);
+	} catch (error) {
+		spinner.stop(`Failed to launch app on "${device.name}"`);
+		throw new Error(`Failed to launch the app on simulator: ${error}`);
+	}
+};
+const bootSimulator = async ({ device }) => {
+	try {
+		await execa("xcrun", [
+			"simctl",
+			"boot",
+			device.udid
+		]);
+	} catch (error) {
+		if ((error instanceof Error ? error.message : String(error)).includes("Unable to boot device in current state: Booted")) {
+			p.log.info(`Simulator ${device.udid} already booted. Skipping.`);
+			return;
+		}
+		throw new Error(`Failed to boot simulator: ${error}`);
+	}
+};
+
+//#endregion
+//#region src/utils/device.ts
+/**
+* Parses devicectl output to Device array
+* @param devicectlOutput - Raw devicectl JSON output
+* @returns Array of parsed devices
+*/
+const parseDevicectlList = (devicectlOutput) => {
+	return devicectlOutput.map((device) => ({
+		name: device.deviceProperties.name,
+		udid: device.hardwareProperties.udid,
+		version: `${device.hardwareProperties.platform} ${device.deviceProperties.osVersionNumber}`,
+		platform: getPlatformFromOsVersion(device.hardwareProperties.platform),
+		state: device.deviceProperties.bootState === "booted" ? "Booted" : "Shutdown",
+		type: "device"
+	}));
+};
+/**
+* Gets physical iOS devices using devicectl
+*/
+const getDevices = async () => {
+	const tmpPath = path.resolve(os.tmpdir(), "iosPhysicalDevices.json");
+	try {
+		await execa("xcrun", [
+			"devicectl",
+			"list",
+			"devices",
+			"-j",
+			tmpPath
+		]);
+		return parseDevicectlList(JSON.parse(fs.readFileSync(tmpPath, "utf8")).result.devices);
+	} catch (error) {
+		throw new Error(`Failed to get devices: ${error}`);
+	}
+};
+/**
+* Gets iOS simulators using simctl with JSON output
+*/
+const getSimulators = async () => {
+	try {
+		const { stdout } = await execa("xcrun", [
+			"simctl",
+			"list",
+			"devices",
+			"available",
+			"-j"
+		]);
+		return parseSimctlJson(JSON.parse(stdout));
+	} catch (error) {
+		throw new Error(`Failed to get simulators: ${error}`);
+	}
+};
+/**
+* Parses simctl JSON output to Device array
+*/
+const parseSimctlJson = (simctlOutput) => {
+	const devices = [];
+	for (const [runtime, runtimeDevices] of Object.entries(simctlOutput.devices)) {
+		const osVersion = runtime.replace("com.apple.CoreSimulator.SimRuntime.", "").replace(/-/g, " ");
+		const platform = getPlatformFromOsVersion(osVersion.split(" ")[0]);
+		if (!platform) continue;
+		for (const device of runtimeDevices) if (device.isAvailable) devices.push({
+			name: device.name,
+			udid: device.udid,
+			version: osVersion,
+			platform,
+			state: device.state,
+			type: "simulator"
+		});
+	}
+	return devices;
+};
+/**
+* Maps OS version string to Apple platform
+* @param osVersion - OS version string from devicectl/simctl
+* @returns Apple platform or undefined if unknown
+*/
+const getPlatformFromOsVersion = (osVersion) => {
+	switch (osVersion) {
+		case "iOS": return "ios";
+		default: return "ios";
+	}
+};
+/**
+* Lists devices and simulators for a specific platform
+* @param platform - Apple platform to filter by
+* @param options - Filtering options
+* @returns Array of devices filtered by options
+*/
+const listDevices = async (platform, options = {}) => {
+	const spinner = p.spinner();
+	spinner.start(`Discovering ${platform} devices`);
+	try {
+		const [simulators, devices] = await Promise.all([getSimulators(), getDevices().catch(() => [])]);
+		let allDevices = [...devices, ...simulators].filter((device) => device.platform === platform);
+		if (options.deviceType) allDevices = allDevices.filter((d) => d.type === options.deviceType);
+		if (options.state && options.state !== "all") allDevices = allDevices.filter((d) => d.state === options.state);
+		spinner.stop(`Found ${allDevices.length} ${platform} devices`);
+		return allDevices;
+	} catch (error) {
+		spinner.stop(`Failed to discover ${platform} devices`);
+		throw error;
+	}
+};
+const matchingDevice = (devices, deviceArg, options = {}) => {
+	let filtered = [...devices];
+	if (options.deviceType) filtered = filtered.filter((d) => d.type === options.deviceType);
+	if (options.bootedOnly) filtered = filtered.filter((d) => d.state === "Booted");
+	const byName = filtered.find((d) => d.name === deviceArg);
+	if (byName) return byName;
+	const byFormattedName = filtered.find((d) => formatDeviceName(d) === deviceArg);
+	if (byFormattedName) return byFormattedName;
+	const byUdid = filtered.find((d) => d.udid === deviceArg);
+	if (byUdid) return byUdid;
+};
+const formatDeviceName = (device) => {
+	return device.version ? `${device.name} (${device.version})` : device.name;
+};
+const selectTargetDevice = async ({ platform, interactive, deviceOption }) => {
+	const availableDevices = await listDevices(platform);
+	if (deviceOption === true && !interactive) {
+		p.log.error("you can't select device manually with non-interactive cli mode(without -i option).");
+		process.exit(1);
+	}
+	if (typeof deviceOption === "string") {
+		const matchedDevice = matchingDevice(availableDevices, deviceOption);
+		if (!matchedDevice) {
+			p.log.error(`device '${deviceOption}' isn't included in the attached devices.`);
+			process.exit(1);
+		}
+		return matchedDevice;
+	}
+	if (interactive) {
+		if (!availableDevices.length) {
+			p.log.error("you passed -d option but there is no attached devices.");
+			process.exit(1);
+		}
+		const device = await p.select({
+			message: "Target Device",
+			options: availableDevices.map((d) => ({
+				value: d,
+				label: `${d.name} (${d.type}) - ${d.state}`,
+				hint: d.udid
+			}))
+		});
+		if (p.isCancel(device)) process.exit(1);
+		return device;
+	}
+	const bootedDevices = await listDevices(platform, { state: "Booted" });
+	if (bootedDevices.length > 0) return bootedDevices[0];
+};
+const Device = {
+	listDevices,
+	selectTargetDevice
+};
+
+//#endregion
+//#region src/runIos.ts
+const runIos = async ({ schemeConfig: _schemeConfig, runOption }) => {
+	const { interactive, device: deviceOption } = runOption;
+	const iosProjectPath = path.join(getCwd(), "ios");
+	const schemeConfig = await enrichNativeBuildIosScheme(_schemeConfig);
+	const device = await Device.selectTargetDevice({
+		platform: "ios",
+		deviceOption,
+		interactive
+	});
+	if (!device) {
+		const simulators = await Device.listDevices("ios", { deviceType: "simulator" });
+		if (simulators.length === 0) {
+			p.log.error("No simulators found. Please create a simulator in Xcode.");
+			process.exit(1);
+		}
+		p.log.info(`Using first available simulator: ${simulators[0].name}`);
+		const selectedDevice = simulators[0];
+		p.log.info(`Building for ${selectedDevice.name}...`);
+		const result$1 = await buildXcodeProject({
+			sourceDir: iosProjectPath,
+			platform: schemeConfig.platform,
+			scheme: schemeConfig.scheme,
+			configuration: schemeConfig.configuration,
+			deviceType: selectedDevice.type,
+			udid: selectedDevice.udid,
+			installPods: schemeConfig.installPods,
+			extraParams: schemeConfig.extraParams
+		});
+		const runnerOptions$1 = {
+			bundleIdentifier: schemeConfig.bundleIdentifier,
+			sourceDir: iosProjectPath,
+			launch: true,
+			infoPlistPath: result$1.infoPlistPath
+		};
+		await installAndLaunchOnSimulator({
+			device: selectedDevice,
+			appPath: result$1.appPath,
+			options: runnerOptions$1
+		});
+		p.outro("Success 🎉");
+		return result$1;
+	}
+	p.log.info(`Building for ${device.name}...`);
+	const result = await buildXcodeProject({
+		sourceDir: iosProjectPath,
+		platform: schemeConfig.platform,
+		scheme: schemeConfig.scheme,
+		configuration: schemeConfig.configuration,
+		deviceType: device.type,
+		udid: device.udid,
+		installPods: schemeConfig.installPods,
+		extraParams: schemeConfig.extraParams
+	});
+	const runnerOptions = {
+		bundleIdentifier: schemeConfig.bundleIdentifier,
+		sourceDir: iosProjectPath,
+		launch: true
+	};
+	if (device.type === "simulator") await installAndLaunchOnSimulator({
+		device,
+		appPath: result.appPath,
+		options: {
+			...runnerOptions,
+			infoPlistPath: result.infoPlistPath
+		}
+	});
+	else await installAndLaunchOnDevice({
+		device,
+		appPath: result.appPath,
+		options: runnerOptions
+	});
+	p.outro("Success 🎉");
+	return result;
+};
+
+//#endregion
+export { buildIos, runIos };