@teardown/cli 1.2.38 → 2.0.41

package/src/cli/commands/run.ts

@@ -0,0 +1,727 @@
+/**
+ * Run command - runs the app on iOS or Android devices/simulators
+ */
+
+import { exec, spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { createInterface } from "node:readline";
+import { promisify } from "node:util";
+import chalk from "chalk";
+import { Command } from "commander";
+import ora from "ora";
+
+const execAsync = promisify(exec);
+
+/**
+ * Raw device info from xcrun simctl list devices --json
+ */
+interface SimctlDevice {
+	name: string;
+	udid: string;
+	state: "Booted" | "Shutdown";
+	isAvailable: boolean;
+	deviceTypeIdentifier: string;
+}
+
+/**
+ * Simctl devices JSON structure
+ */
+interface SimctlDevicesOutput {
+	devices: Record<string, SimctlDevice[]>;
+}
+
+/**
+ * iOS Simulator device info
+ */
+interface iOSDevice {
+	name: string;
+	udid: string;
+	state: "Booted" | "Shutdown";
+	isAvailable: boolean;
+	deviceTypeIdentifier: string;
+	runtime: string;
+}
+
+/**
+ * Android device/emulator info
+ */
+interface AndroidDevice {
+	id: string;
+	name: string;
+	type: "emulator" | "device";
+	state: "online" | "offline" | "available";
+}
+
+/**
+ * Check if native project exists for platform
+ */
+function hasNativeProject(platform: "ios" | "android"): boolean {
+	const projectRoot = process.cwd();
+	if (platform === "ios") {
+		return existsSync(join(projectRoot, "ios"));
+	}
+	return existsSync(join(projectRoot, "android"));
+}
+
+/**
+ * Check if iOS Pods are installed
+ */
+function hasPodsInstalled(): boolean {
+	const projectRoot = process.cwd();
+	const podsDir = join(projectRoot, "ios", "Pods");
+	const workspacePath = join(projectRoot, "ios");
+
+	// Check if Pods directory exists
+	if (!existsSync(podsDir)) {
+		return false;
+	}
+
+	// Check if there's a .xcworkspace file (created by pod install)
+	try {
+		const iosContents = require("node:fs").readdirSync(workspacePath);
+		return iosContents.some((file: string) => file.endsWith(".xcworkspace"));
+	} catch {
+		return false;
+	}
+}
+
+/**
+ * Run pod install manually
+ */
+async function runPodInstall(): Promise<boolean> {
+	const spinner = ora("Installing CocoaPods dependencies...").start();
+	const iosDir = join(process.cwd(), "ios");
+
+	return new Promise((resolve) => {
+		const proc = spawn("pod", ["install", "--repo-update"], {
+			cwd: iosDir,
+			stdio: ["ignore", "pipe", "pipe"],
+			env: {
+				...process.env,
+				LANG: "en_US.UTF-8",
+				LC_ALL: "en_US.UTF-8",
+			},
+		});
+
+		let stderr = "";
+
+		proc.stdout?.on("data", () => {
+			// Ignore stdout, just wait for completion
+		});
+
+		proc.stderr?.on("data", (data) => {
+			stderr += data.toString();
+		});
+
+		proc.on("close", (code) => {
+			if (code === 0) {
+				spinner.succeed("CocoaPods dependencies installed");
+				resolve(true);
+			} else {
+				spinner.fail("Failed to install CocoaPods dependencies");
+				console.error(chalk.red(stderr));
+				console.log(chalk.yellow("\nTry running manually:"));
+				console.log(chalk.gray("  cd ios && pod install --repo-update"));
+				resolve(false);
+			}
+		});
+
+		proc.on("error", (err) => {
+			spinner.fail(`Failed to run pod install: ${err.message}`);
+			resolve(false);
+		});
+	});
+}
+
+/**
+ * Run prebuild if native project doesn't exist
+ */
+async function ensureNativeProject(platform: "ios" | "android"): Promise<boolean> {
+	if (hasNativeProject(platform)) {
+		// For iOS, also check if Pods are installed
+		if (platform === "ios" && !hasPodsInstalled()) {
+			console.log(chalk.yellow("\niOS Pods not installed. Running pod install...\n"));
+			const podResult = await runPodInstall();
+			if (!podResult) {
+				return false;
+			}
+		}
+		return true;
+	}
+
+	console.log(chalk.yellow(`\nNo ${platform} project found. Running prebuild first...\n`));
+
+	const prebuildSuccess = await new Promise<boolean>((resolve) => {
+		const proc = spawn("npx", ["teardown", "prebuild", "--platform", platform], {
+			stdio: "inherit",
+			shell: true,
+			cwd: process.cwd(),
+			env: {
+				...process.env,
+				LANG: "en_US.UTF-8",
+				LC_ALL: "en_US.UTF-8",
+			},
+		});
+
+		proc.on("close", (code) => {
+			if (code === 0) {
+				console.log();
+				resolve(true);
+			} else {
+				console.error(chalk.red("\nPrebuild failed. Please fix the issues and try again."));
+				resolve(false);
+			}
+		});
+
+		proc.on("error", () => {
+			resolve(false);
+		});
+	});
+
+	if (!prebuildSuccess) {
+		return false;
+	}
+
+	// After prebuild, verify Pods are installed for iOS
+	if (platform === "ios" && !hasPodsInstalled()) {
+		console.log(chalk.yellow("\nPods not installed after prebuild. Trying pod install...\n"));
+		return runPodInstall();
+	}
+
+	return true;
+}
+
+/**
+ * Start Metro bundler in foreground (runs after build completes)
+ */
+function startBundlerInForeground(port: string): void {
+	console.log(chalk.blue(`\nStarting Metro bundler on port ${port} with --reset-cache...\n`));
+
+	const proc = spawn("npx", ["react-native", "start", "--port", port, "--reset-cache"], {
+		stdio: "inherit",
+		shell: true,
+		cwd: process.cwd(),
+		env: {
+			...process.env,
+			LANG: "en_US.UTF-8",
+		},
+	});
+
+	proc.on("close", (code) => {
+		if (code !== 0) {
+			console.error(chalk.red(`Metro bundler exited with code ${code}`));
+		}
+	});
+
+	proc.on("error", (err) => {
+		console.error(chalk.red(`Failed to start Metro bundler: ${err.message}`));
+	});
+}
+
+interface RunOptions {
+	device?: string;
+	picker: boolean;
+	release?: boolean;
+	port: string;
+	bundler: boolean;
+	/** iOS: Build configuration (Debug/Release) */
+	configuration?: string;
+	/** iOS: Xcode scheme to build */
+	scheme?: string;
+	/** Android: Build variant (e.g., debug, release) */
+	variant?: string;
+	/** Clean build before running */
+	clean?: boolean;
+}
+
+/**
+ * Create the run command
+ */
+export function createRunCommand(): Command {
+	const run = new Command("run")
+		.description("Run the app on a device or simulator")
+		.argument("<platform>", "Platform to run on (ios or android)")
+		.option("-d, --device <device>", "Specific device name or ID")
+		.option("--no-picker", "Skip device picker, use first available device")
+		.option("--release", "Run in release mode")
+		.option("--port <port>", "Metro bundler port", "8081")
+		.option("--no-bundler", "Skip starting the Metro bundler")
+		.option("--configuration <config>", "iOS build configuration (Debug/Release)")
+		.option("--scheme <scheme>", "iOS Xcode scheme to build")
+		.option("--variant <variant>", "Android build variant (e.g., debug, release)")
+		.option("--clean", "Clean build before running", false)
+		.action(async (platform: string, options: RunOptions) => {
+			if (platform !== "ios" && platform !== "android") {
+				console.error(chalk.red(`Invalid platform: ${platform}. Use 'ios' or 'android'.`));
+				process.exit(1);
+			}
+
+			try {
+				// Ensure native project exists (auto-prebuild if needed)
+				const hasProject = await ensureNativeProject(platform);
+				if (!hasProject) {
+					process.exit(1);
+				}
+
+				if (platform === "ios") {
+					await runIOS(options);
+				} else {
+					await runAndroid(options);
+				}
+
+				// Start bundler after build completes (unless --no-bundler or --release)
+				if (options.bundler && !options.release) {
+					startBundlerInForeground(options.port);
+				}
+			} catch (error) {
+				console.error(chalk.red(`Failed to run app: ${error instanceof Error ? error.message : error}`));
+				process.exit(1);
+			}
+		});
+
+	return run;
+}
+
+/**
+ * Run on iOS
+ */
+async function runIOS(options: RunOptions): Promise<void> {
+	const spinner = ora("Detecting iOS devices...").start();
+
+	try {
+		const devices = await getIOSDevices();
+		spinner.stop();
+
+		if (devices.length === 0) {
+			console.log(chalk.yellow("\nNo iOS simulators found."));
+			console.log(chalk.gray("Open Xcode and create a simulator, or install Xcode Command Line Tools."));
+			process.exit(1);
+		}
+
+		let selectedDevice: iOSDevice;
+
+		if (options.device) {
+			// Find device by name or udid
+			const found = devices.find(
+				(d) => d.name.toLowerCase() === options.device?.toLowerCase() || d.udid === options.device
+			);
+			if (!found) {
+				console.error(chalk.red(`Device not found: ${options.device}`));
+				console.log(chalk.gray("\nAvailable devices:"));
+				for (const d of devices) {
+					console.log(chalk.gray(`  - ${d.name} (${d.state})`));
+				}
+				process.exit(1);
+			}
+			selectedDevice = found;
+		} else if (!options.picker) {
+			// Use first booted device, or first available
+			selectedDevice = devices.find((d) => d.state === "Booted") || devices[0];
+		} else {
+			// Show device picker
+			selectedDevice = await pickDevice(devices, "iOS");
+		}
+
+		console.log(chalk.blue(`\nSelected device: ${selectedDevice.name}`));
+
+		// Boot device if needed
+		if (selectedDevice.state !== "Booted") {
+			const bootSpinner = ora(`Booting ${selectedDevice.name}...`).start();
+			await bootIOSSimulator(selectedDevice.udid);
+			bootSpinner.succeed(`${selectedDevice.name} is now running`);
+		}
+
+		// Run the app
+		console.log(chalk.blue("\nStarting app on iOS simulator...\n"));
+
+		const args = [
+			"react-native",
+			"run-ios",
+			"--simulator",
+			selectedDevice.name,
+			"--port",
+			options.port,
+			"--no-packager",
+		];
+
+		// Handle configuration/release mode
+		const configuration = options.configuration || (options.release ? "Release" : "Debug");
+		args.push("--mode", configuration);
+
+		// Handle scheme if specified
+		if (options.scheme) {
+			args.push("--scheme", options.scheme);
+		}
+
+		// Handle clean build
+		if (options.clean) {
+			console.log(chalk.blue("Cleaning iOS build..."));
+			try {
+				await execAsync("xcodebuild clean", { cwd: join(process.cwd(), "ios") });
+			} catch {
+				// Ignore clean errors
+			}
+		}
+
+		await runCommand("npx", args);
+	} catch (error) {
+		spinner.fail("Failed to detect iOS devices");
+		throw error;
+	}
+}
+
+/**
+ * Run on Android
+ */
+async function runAndroid(options: RunOptions): Promise<void> {
+	const spinner = ora("Detecting Android devices...").start();
+
+	try {
+		const devices = await getAndroidDevices();
+		spinner.stop();
+
+		if (devices.length === 0) {
+			console.log(chalk.yellow("\nNo Android devices or emulators found."));
+
+			// Check for available AVDs
+			const avds = await getAndroidAVDs();
+			if (avds.length > 0) {
+				console.log(chalk.gray("\nAvailable emulators (not running):"));
+				for (const avd of avds) {
+					console.log(chalk.gray(`  - ${avd}`));
+				}
+
+				const selectedAVD = await pickAVD(avds);
+				if (selectedAVD) {
+					const bootSpinner = ora(`Starting ${selectedAVD}...`).start();
+					await startAndroidEmulator(selectedAVD);
+					bootSpinner.succeed(`${selectedAVD} is starting`);
+
+					// Wait for device to be ready
+					await waitForAndroidDevice();
+
+					// Re-fetch devices
+					const newDevices = await getAndroidDevices();
+					if (newDevices.length > 0) {
+						await launchAndroidApp(newDevices[0], {
+							release: options.release,
+							port: options.port,
+							variant: options.variant,
+							clean: options.clean,
+						});
+						return;
+					}
+				}
+			}
+
+			console.log(chalk.gray("\nTo create an emulator, run: Android Studio > Tools > Device Manager"));
+			process.exit(1);
+		}
+
+		let selectedDevice: AndroidDevice;
+
+		if (options.device) {
+			const found = devices.find(
+				(d) => d.name.toLowerCase() === options.device?.toLowerCase() || d.id === options.device
+			);
+			if (!found) {
+				console.error(chalk.red(`Device not found: ${options.device}`));
+				console.log(chalk.gray("\nAvailable devices:"));
+				for (const d of devices) {
+					console.log(chalk.gray(`  - ${d.name} (${d.type})`));
+				}
+				process.exit(1);
+			}
+			selectedDevice = found;
+		} else if (!options.picker || devices.length === 1) {
+			selectedDevice = devices[0];
+		} else {
+			selectedDevice = await pickAndroidDevice(devices);
+		}
+
+		await launchAndroidApp(selectedDevice, {
+			release: options.release,
+			port: options.port,
+			variant: options.variant,
+			clean: options.clean,
+		});
+	} catch (error) {
+		spinner.fail("Failed to detect Android devices");
+		throw error;
+	}
+}
+
+/**
+ * Launch Android app on device
+ */
+async function launchAndroidApp(
+	device: AndroidDevice,
+	options: { release?: boolean; port: string; variant?: string; clean?: boolean }
+): Promise<void> {
+	console.log(chalk.blue(`\nSelected device: ${device.name} (${device.type})`));
+	console.log(chalk.blue("\nStarting app on Android...\n"));
+
+	// Handle clean build
+	if (options.clean) {
+		console.log(chalk.blue("Cleaning Android build..."));
+		try {
+			await execAsync("./gradlew clean", { cwd: join(process.cwd(), "android") });
+		} catch {
+			// Ignore clean errors
+		}
+	}
+
+	const args = ["react-native", "run-android", "--port", options.port, "--no-packager"];
+
+	if (device.type === "device") {
+		args.push("--deviceId", device.id);
+	}
+
+	// Handle variant or release mode
+	if (options.variant) {
+		args.push("--variant", options.variant);
+	} else if (options.release) {
+		args.push("--mode", "release");
+	}
+
+	await runCommand("npx", args);
+}
+
+/**
+ * Get list of iOS simulators
+ */
+async function getIOSDevices(): Promise<iOSDevice[]> {
+	try {
+		const { stdout } = await execAsync("xcrun simctl list devices --json");
+		const data = JSON.parse(stdout) as SimctlDevicesOutput;
+
+		const devices: iOSDevice[] = [];
+
+		for (const [runtime, runtimeDevices] of Object.entries(data.devices)) {
+			if (!runtime.includes("iOS")) continue;
+
+			for (const device of runtimeDevices) {
+				if (device.isAvailable) {
+					devices.push({
+						name: device.name,
+						udid: device.udid,
+						state: device.state,
+						isAvailable: device.isAvailable,
+						deviceTypeIdentifier: device.deviceTypeIdentifier,
+						runtime: runtime.replace("com.apple.CoreSimulator.SimRuntime.", "").replace("-", " "),
+					});
+				}
+			}
+		}
+
+		// Sort: booted first, then by name
+		devices.sort((a, b) => {
+			if (a.state === "Booted" && b.state !== "Booted") return -1;
+			if (a.state !== "Booted" && b.state === "Booted") return 1;
+			return a.name.localeCompare(b.name);
+		});
+
+		return devices;
+	} catch {
+		return [];
+	}
+}
+
+/**
+ * Boot an iOS simulator
+ */
+async function bootIOSSimulator(udid: string): Promise<void> {
+	await execAsync(`xcrun simctl boot ${udid}`);
+	// Open Simulator app
+	await execAsync("open -a Simulator");
+}
+
+/**
+ * Get list of Android devices
+ */
+async function getAndroidDevices(): Promise<AndroidDevice[]> {
+	try {
+		const { stdout } = await execAsync("adb devices -l");
+		const lines = stdout.trim().split("\n").slice(1);
+
+		const devices: AndroidDevice[] = [];
+
+		for (const line of lines) {
+			if (!line.trim()) continue;
+
+			const parts = line.split(/\s+/);
+			const id = parts[0];
+			const status = parts[1];
+
+			if (status !== "device") continue;
+
+			// Get device name
+			const modelMatch = line.match(/model:(\S+)/);
+			const productMatch = line.match(/product:(\S+)/);
+			const name = modelMatch?.[1] || productMatch?.[1] || id;
+
+			devices.push({
+				id,
+				name: name.replace(/_/g, " "),
+				type: id.startsWith("emulator") ? "emulator" : "device",
+				state: "online",
+			});
+		}
+
+		return devices;
+	} catch {
+		return [];
+	}
+}
+
+/**
+ * Get list of available Android AVDs
+ */
+async function getAndroidAVDs(): Promise<string[]> {
+	try {
+		const { stdout } = await execAsync("emulator -list-avds");
+		return stdout.trim().split("\n").filter(Boolean);
+	} catch {
+		return [];
+	}
+}
+
+/**
+ * Start an Android emulator
+ */
+async function startAndroidEmulator(avdName: string): Promise<void> {
+	// Start emulator in background
+	spawn("emulator", ["-avd", avdName], {
+		detached: true,
+		stdio: "ignore",
+	}).unref();
+}
+
+/**
+ * Wait for Android device to be ready
+ */
+async function waitForAndroidDevice(timeout = 60000): Promise<void> {
+	const startTime = Date.now();
+
+	while (Date.now() - startTime < timeout) {
+		try {
+			const { stdout } = await execAsync("adb devices");
+			if (stdout.includes("device") && !stdout.includes("offline")) {
+				// Wait a bit more for device to be fully ready
+				await new Promise((resolve) => setTimeout(resolve, 2000));
+				return;
+			}
+		} catch {
+			// Ignore errors
+		}
+		await new Promise((resolve) => setTimeout(resolve, 1000));
+	}
+
+	throw new Error("Timeout waiting for Android device");
+}
+
+/**
+ * Interactive device picker for iOS
+ */
+async function pickDevice(devices: iOSDevice[], platform: string): Promise<iOSDevice> {
+	console.log(chalk.blue(`\n${platform} Devices:`));
+	console.log(chalk.gray("─".repeat(50)));
+
+	devices.forEach((device, index) => {
+		const status = device.state === "Booted" ? chalk.green("● Running") : chalk.gray("○ Stopped");
+		console.log(`  ${chalk.cyan(index + 1)}. ${device.name} ${status}`);
+		console.log(chalk.gray(`     ${device.runtime}`));
+	});
+
+	console.log(chalk.gray("─".repeat(50)));
+
+	const index = await promptNumber(`Select device (1-${devices.length})`, 1, devices.length);
+	return devices[index - 1];
+}
+
+/**
+ * Interactive device picker for Android
+ */
+async function pickAndroidDevice(devices: AndroidDevice[]): Promise<AndroidDevice> {
+	console.log(chalk.blue("\nAndroid Devices:"));
+	console.log(chalk.gray("─".repeat(50)));
+
+	devices.forEach((device, index) => {
+		const typeIcon = device.type === "emulator" ? "📱" : "📲";
+		console.log(`  ${chalk.cyan(index + 1)}. ${typeIcon} ${device.name}`);
+		console.log(chalk.gray(`     ${device.type} - ${device.id}`));
+	});
+
+	console.log(chalk.gray("─".repeat(50)));
+
+	const index = await promptNumber(`Select device (1-${devices.length})`, 1, devices.length);
+	return devices[index - 1];
+}
+
+/**
+ * Interactive AVD picker
+ */
+async function pickAVD(avds: string[]): Promise<string | null> {
+	console.log(chalk.blue("\nAvailable Emulators:"));
+	console.log(chalk.gray("─".repeat(50)));
+
+	avds.forEach((avd, index) => {
+		console.log(`  ${chalk.cyan(index + 1)}. ${avd}`);
+	});
+	console.log(`  ${chalk.cyan(0)}. Cancel`);
+
+	console.log(chalk.gray("─".repeat(50)));
+
+	const index = await promptNumber(`Select emulator to start (0-${avds.length})`, 0, avds.length);
+	return index === 0 ? null : avds[index - 1];
+}
+
+/**
+ * Prompt for a number
+ */
+function promptNumber(message: string, min: number, max: number): Promise<number> {
+	return new Promise((resolve) => {
+		const rl = createInterface({
+			input: process.stdin,
+			output: process.stdout,
+		});
+
+		const ask = () => {
+			rl.question(chalk.yellow(`\n${message}: `), (answer) => {
+				const num = Number.parseInt(answer, 10);
+				if (Number.isNaN(num) || num < min || num > max) {
+					console.log(chalk.red(`Please enter a number between ${min} and ${max}`));
+					ask();
+				} else {
+					rl.close();
+					resolve(num);
+				}
+			});
+		};
+
+		ask();
+	});
+}
+
+/**
+ * Run a command with output streaming
+ */
+function runCommand(command: string, args: string[]): Promise<void> {
+	return new Promise((resolve, reject) => {
+		const proc = spawn(command, args, {
+			stdio: "inherit",
+			shell: true,
+		});
+
+		proc.on("close", (code) => {
+			if (code === 0) {
+				resolve();
+			} else {
+				reject(new Error(`Command exited with code ${code}`));
+			}
+		});
+
+		proc.on("error", reject);
+	});
+}