@teardown/cli 2.0.79 → 2.0.80

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@teardown/cli",
-	"version": "2.0.79",
+	"version": "2.0.80",
 	"private": false,
 	"type": "module",
 	"main": "./src/index.ts",
@@ -76,7 +76,7 @@
 	},
 	"devDependencies": {
 		"@biomejs/biome": "2.3.11",
-		"@teardown/tsconfig": "2.0.79",
+		"@teardown/tsconfig": "2.0.80",
 		"@types/bun": "1.3.5",
 		"@types/ejs": "^3.1.5",
 		"typescript": "5.9.3"

package/src/cli/commands/run.ts

@@ -97,6 +97,73 @@ function hasPodsInstalled(): boolean {
 	}
 }
 
+/**
+ * Parse CocoaPods output line to extract activity status
+ */
+function parsePodOutputLine(line: string): string | null {
+	const trimmed = line.trim();
+	if (!trimmed) return null;
+
+	if (trimmed.startsWith("Analyzing dependencies")) {
+		return "analyzing dependencies";
+	}
+	if (trimmed.startsWith("Downloading dependencies")) {
+		return "downloading dependencies";
+	}
+	if (trimmed.startsWith("Installing")) {
+		const match = trimmed.match(/Installing (\S+)/);
+		return match ? `installing ${match[1]}` : null;
+	}
+	if (trimmed.startsWith("Generating Pods project")) {
+		return "generating Pods project";
+	}
+	if (trimmed.startsWith("Integrating client project")) {
+		return "integrating project";
+	}
+	if (trimmed.includes("Pod installation complete")) {
+		return "completing";
+	}
+	return null;
+}
+
+/**
+ * Get spinner text based on elapsed time
+ */
+function getPodSpinnerText(elapsed: number, lastActivity: string): string {
+	const activity = lastActivity ? ` - ${lastActivity}` : "";
+	const base = `Installing CocoaPods dependencies... (${elapsed}s)`;
+
+	if (elapsed === 60) {
+		return `${base} - still working, this can take a while`;
+	}
+	if (elapsed === 120) {
+		return `${base} - updating pod repos`;
+	}
+	if (elapsed === 180) {
+		return `${base} - this is taking longer than usual`;
+	}
+	return `${base}${activity}`;
+}
+
+/**
+ * Handle pod install failure output
+ */
+function handlePodInstallFailure(stderr: string, stdout: string, isTimeout: boolean): void {
+	if (isTimeout) {
+		console.log(chalk.yellow("\nThis usually means:"));
+		console.log(chalk.gray("  - Network connection issues"));
+		console.log(chalk.gray("  - Slow CocoaPods CDN"));
+		console.log(chalk.gray("  - Large number of pods to install"));
+	} else {
+		console.error(chalk.red(stderr));
+	}
+	if (stdout) {
+		console.log(chalk.gray("\nLast output:"), stdout.slice(-500));
+	}
+	console.log(chalk.yellow("\nTry running manually:"));
+	console.log(chalk.gray("  cd ios && pod install --repo-update"));
+}
+
 /**
  * Run pod install manually
  */
@@ -120,48 +187,19 @@ async function runPodInstall(): Promise<boolean> {
 		let stderr = "";
 		let stdout = "";
 
-		// Update spinner with elapsed time and activity
 		const progressInterval = setInterval(() => {
 			const elapsed = Math.round((Date.now() - startTime) / 1000);
-			const activity = lastActivity ? ` - ${lastActivity}` : "";
-			spinner.text = `Installing CocoaPods dependencies... (${elapsed}s)${activity}`;
-
-			// Warn if taking too long
-			if (elapsed === 60) {
-				spinner.text = `Installing CocoaPods dependencies... (${elapsed}s) - still working, this can take a while`;
-			} else if (elapsed === 120) {
-				spinner.text = `Installing CocoaPods dependencies... (${elapsed}s) - updating pod repos`;
-			} else if (elapsed === 180) {
-				spinner.text = `Installing CocoaPods dependencies... (${elapsed}s) - this is taking longer than usual`;
-			}
+			spinner.text = getPodSpinnerText(elapsed, lastActivity);
 		}, 1000);
 
 		proc.stdout?.on("data", (data) => {
 			const chunk = data.toString();
 			stdout += chunk;
 
-			// Parse CocoaPods output for status
 			for (const line of chunk.split("\n")) {
-				const trimmed = line.trim();
-				if (!trimmed) continue;
-
-				// Extract useful status from pod output
-				if (trimmed.startsWith("Analyzing dependencies")) {
-					lastActivity = "analyzing dependencies";
-				} else if (trimmed.startsWith("Downloading dependencies")) {
-					lastActivity = "downloading dependencies";
-				} else if (trimmed.startsWith("Installing")) {
-					// Extract pod name: "Installing PodName (1.0.0)"
-					const match = trimmed.match(/Installing (\S+)/);
-					if (match) {
-						lastActivity = `installing ${match[1]}`;
-					}
-				} else if (trimmed.startsWith("Generating Pods project")) {
-					lastActivity = "generating Pods project";
-				} else if (trimmed.startsWith("Integrating client project")) {
-					lastActivity = "integrating project";
-				} else if (trimmed.includes("Pod installation complete")) {
-					lastActivity = "completing";
+				const activity = parsePodOutputLine(line);
+				if (activity) {
+					lastActivity = activity;
 				}
 			}
 		});
@@ -179,12 +217,7 @@ async function runPodInstall(): Promise<boolean> {
 				resolve(true);
 			} else {
 				spinner.fail(`Failed to install CocoaPods dependencies after ${elapsed}s`);
-				console.error(chalk.red(stderr));
-				if (stdout) {
-					console.log(chalk.gray("Last output:"), stdout.slice(-500));
-				}
-				console.log(chalk.yellow("\nTry running manually:"));
-				console.log(chalk.gray("  cd ios && pod install --repo-update"));
+				handlePodInstallFailure(stderr, stdout, false);
 				resolve(false);
 			}
 		});
@@ -195,21 +228,13 @@ async function runPodInstall(): Promise<boolean> {
 			resolve(false);
 		});
 
-		// Timeout after 10 minutes (pod install can be slow)
 		const timeout = setTimeout(
 			() => {
 				clearInterval(progressInterval);
 				const elapsed = Math.round((Date.now() - startTime) / 1000);
 				proc.kill("SIGTERM");
 				spinner.fail(`pod install timed out after ${elapsed}s`);
-				console.log(chalk.yellow("\nThis usually means:"));
-				console.log(chalk.gray("  - Network connection issues"));
-				console.log(chalk.gray("  - Slow CocoaPods CDN"));
-				console.log(chalk.gray("  - Large number of pods to install"));
-				console.log(chalk.gray("\nTry running manually: cd ios && pod install --repo-update"));
-				if (stdout) {
-					console.log(chalk.gray("\nLast output:"), stdout.slice(-500));
-				}
+				handlePodInstallFailure(stderr, stdout, true);
 				resolve(false);
 			},
 			10 * 60 * 1000
@@ -293,6 +318,289 @@ interface RunOptions {
 	clean?: boolean;
 }
 
+/**
+ * Pre-generate routes if navigation-metro is installed
+ */
+function preGenerateRoutes(projectRoot: string): void {
+	const navigationMetroPath = join(projectRoot, "node_modules/@teardown/navigation-metro");
+	const navConfig = getNavigationConfig(projectRoot);
+
+	if (!existsSync(navigationMetroPath) || !navConfig) {
+		return;
+	}
+
+	const routesDir = resolve(projectRoot, navConfig.routesDir);
+	const generatedDir = resolve(projectRoot, navConfig.generatedDir);
+
+	if (!existsSync(routesDir)) {
+		return;
+	}
+
+	try {
+		// Dynamic require from user's node_modules
+		// eslint-disable-next-line @typescript-eslint/no-require-imports
+		const { generateAllRouteFiles } = require(navigationMetroPath) as {
+			generateAllRouteFiles: (opts: {
+				routesDir: string;
+				generatedDir: string;
+				prefixes: string[];
+				verbose: boolean;
+			}) => void;
+		};
+		const slug = getAppScheme(projectRoot) || "app";
+		generateAllRouteFiles({
+			routesDir,
+			generatedDir,
+			prefixes: [`${slug}://`],
+			verbose: false,
+		});
+	} catch {
+		// Ignore - Metro will regenerate
+	}
+}
+
+/**
+ * Select iOS device based on options
+ */
+async function selectIOSDevice(devices: iOSDevice[], options: RunOptions): Promise<iOSDevice> {
+	if (options.device) {
+		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);
+		}
+		return found;
+	}
+
+	if (!options.picker) {
+		return devices.find((d) => d.state === "Booted") || devices[0];
+	}
+
+	return pickDevice(devices, "iOS");
+}
+
+/**
+ * Build iOS command arguments
+ */
+function buildIOSArgs(options: RunOptions, deviceName: string): string[] {
+	const args = ["react-native", "run-ios", "--simulator", deviceName, "--port", options.port, "--no-packager"];
+
+	const configuration = options.configuration || (options.release ? "Release" : "Debug");
+	args.push("--mode", configuration);
+
+	if (options.scheme) {
+		args.push("--scheme", options.scheme);
+	}
+
+	return args;
+}
+
+/**
+ * Build Android command arguments
+ */
+function buildAndroidArgs(
+	device: AndroidDevice,
+	options: { release?: boolean; port: string; variant?: string }
+): string[] {
+	const args = ["react-native", "run-android", "--port", options.port, "--no-packager"];
+
+	if (device.type === "device") {
+		args.push("--deviceId", device.id);
+	}
+
+	if (options.variant) {
+		args.push("--variant", options.variant);
+	} else if (options.release) {
+		args.push("--mode", "release");
+	}
+
+	return args;
+}
+
+/**
+ * Clean build directory if requested
+ */
+async function cleanBuildIfNeeded(platform: "ios" | "android", shouldClean?: boolean): Promise<void> {
+	if (!shouldClean) {
+		return;
+	}
+
+	if (platform === "ios") {
+		console.log(chalk.blue("Cleaning iOS build..."));
+		try {
+			await execAsync("xcodebuild clean", { cwd: join(process.cwd(), "ios") });
+		} catch {
+			// Ignore clean errors
+		}
+	} else {
+		console.log(chalk.blue("Cleaning Android build..."));
+		try {
+			await execAsync("./gradlew clean", { cwd: join(process.cwd(), "android") });
+		} catch {
+			// Ignore clean errors
+		}
+	}
+}
+
+/**
+ * Launch app with bundler connection via deep link
+ */
+async function launchWithBundlerIfNeeded(
+	platform: "ios" | "android",
+	metroProcess: ChildProcess | null,
+	options: { release?: boolean; port: string },
+	deviceId: string,
+	deviceType?: "emulator" | "device"
+): Promise<void> {
+	if (!metroProcess || options.release) {
+		return;
+	}
+
+	const scheme = getAppScheme(process.cwd());
+	if (!scheme) {
+		return;
+	}
+
+	let bundlerUrl: string;
+	if (platform === "android" && deviceType === "emulator") {
+		bundlerUrl = `http://10.0.2.2:${options.port}`;
+	} else {
+		bundlerUrl = `http://localhost:${options.port}`;
+	}
+
+	console.log(chalk.blue("\nLaunching app with bundler connection..."));
+	try {
+		await launchAppWithBundler(platform, scheme, bundlerUrl, deviceId);
+		console.log(chalk.green(`✓ App launched with bundler: ${bundlerUrl}`));
+	} catch (error) {
+		console.log(
+			chalk.yellow(`Note: Deep link launch skipped - ${error instanceof Error ? error.message : "unknown error"}`)
+		);
+	}
+}
+
+/**
+ * Select Android device based on options
+ */
+async function selectAndroidDevice(devices: AndroidDevice[], options: RunOptions): Promise<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);
+		}
+		return found;
+	}
+
+	if (!options.picker || devices.length === 1) {
+		return devices[0];
+	}
+
+	return pickAndroidDevice(devices);
+}
+
+/**
+ * Handle case when no Android devices are running but AVDs are available
+ * Returns true if an emulator was started and app should be launched
+ */
+async function handleNoDevicesWithAVDs(options: RunOptions, metroProcess: ChildProcess | null): Promise<boolean> {
+	const avds = await getAndroidAVDs();
+	if (avds.length === 0) {
+		return false;
+	}
+
+	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) {
+		return false;
+	}
+
+	const bootSpinner = ora(`Starting ${selectedAVD}...`).start();
+	await startAndroidEmulator(selectedAVD);
+	bootSpinner.succeed(`${selectedAVD} is starting`);
+
+	await waitForAndroidDevice();
+
+	const newDevices = await getAndroidDevices();
+	if (newDevices.length === 0) {
+		return false;
+	}
+
+	await launchAndroidApp(
+		newDevices[0],
+		{
+			release: options.release,
+			port: options.port,
+			variant: options.variant,
+			clean: options.clean,
+		},
+		metroProcess
+	);
+	return true;
+}
+
+/**
+ * Execute the run command for a platform
+ */
+async function executeRunCommand(platform: "ios" | "android", options: RunOptions): Promise<void> {
+	let metroProcess: ChildProcess | null = null;
+
+	const cleanup = () => {
+		if (metroProcess) {
+			metroProcess.kill("SIGTERM");
+		}
+		process.exit(0);
+	};
+	process.on("SIGINT", cleanup);
+	process.on("SIGTERM", cleanup);
+
+	try {
+		const hasProject = await ensureNativeProject(platform);
+		if (!hasProject) {
+			process.exit(1);
+		}
+
+		if (options.bundler && !options.release) {
+			preGenerateRoutes(process.cwd());
+			metroProcess = await startMetroAndWait(options.port, platform);
+		}
+
+		if (platform === "ios") {
+			await runIOS(options, metroProcess);
+		} else {
+			await runAndroid(options, metroProcess);
+		}
+
+		if (metroProcess) {
+			console.log(chalk.blue("\n─".repeat(50)));
+			console.log(chalk.blue("Metro bundler running. Press Ctrl+C to stop.\n"));
+			attachBundlerToForeground(metroProcess);
+		}
+	} catch (error) {
+		if (metroProcess) {
+			metroProcess.kill("SIGTERM");
+		}
+		console.error(chalk.red(`Failed to run app: ${error instanceof Error ? error.message : error}`));
+		process.exit(1);
+	}
+}
+
 /**
  * Create the run command
  */
@@ -314,87 +622,7 @@ export function createRunCommand(): Command {
 				console.error(chalk.red(`Invalid platform: ${platform}. Use 'ios' or 'android'.`));
 				process.exit(1);
 			}
-
-			// Track Metro process for cleanup
-			let metroProcess: ChildProcess | null = null;
-
-			// Handle SIGINT (Ctrl+C) to clean up Metro
-			const cleanup = () => {
-				if (metroProcess) {
-					metroProcess.kill("SIGTERM");
-				}
-				process.exit(0);
-			};
-			process.on("SIGINT", cleanup);
-			process.on("SIGTERM", cleanup);
-
-			try {
-				// Ensure native project exists (auto-prebuild if needed)
-				const hasProject = await ensureNativeProject(platform);
-				if (!hasProject) {
-					process.exit(1);
-				}
-
-				// Start Metro bundler FIRST (unless --no-bundler or --release)
-				if (options.bundler && !options.release) {
-					// Pre-generate routes if navigation-metro is installed
-					const projectRoot = process.cwd();
-					const navigationMetroPath = join(projectRoot, "node_modules/@teardown/navigation-metro");
-					const navConfig = getNavigationConfig(projectRoot);
-
-					if (existsSync(navigationMetroPath) && navConfig) {
-						const routesDir = resolve(projectRoot, navConfig.routesDir);
-						const generatedDir = resolve(projectRoot, navConfig.generatedDir);
-
-						if (existsSync(routesDir)) {
-							try {
-								// Dynamic require from user's node_modules
-								// eslint-disable-next-line @typescript-eslint/no-require-imports
-								const { generateAllRouteFiles } = require(navigationMetroPath) as {
-									generateAllRouteFiles: (opts: {
-										routesDir: string;
-										generatedDir: string;
-										prefixes: string[];
-										verbose: boolean;
-									}) => void;
-								};
-								const slug = getAppScheme(projectRoot) || "app";
-								generateAllRouteFiles({
-									routesDir,
-									generatedDir,
-									prefixes: [`${slug}://`],
-									verbose: false,
-								});
-							} catch {
-								// Ignore - Metro will regenerate
-							}
-						}
-					}
-
-					metroProcess = await startMetroAndWait(options.port, platform);
-				}
-
-				// Run platform-specific build and launch
-				if (platform === "ios") {
-					await runIOS(options, metroProcess);
-				} else {
-					await runAndroid(options, metroProcess);
-				}
-
-				// If Metro is running, attach to foreground
-				if (metroProcess) {
-					console.log(chalk.blue("\n─".repeat(50)));
-					console.log(chalk.blue("Metro bundler running. Press Ctrl+C to stop.\n"));
-					attachBundlerToForeground(metroProcess);
-				}
-			} catch (error) {
-				// Clean up Metro on error
-				if (metroProcess) {
-					metroProcess.kill("SIGTERM");
-				}
-				console.error(chalk.red(`Failed to run app: ${error instanceof Error ? error.message : error}`));
-				process.exit(1);
-			}
+			await executeRunCommand(platform, options);
 		});
 
 	return run;
@@ -452,30 +680,7 @@ async function runIOS(options: RunOptions, metroProcess: ChildProcess | null): P
 			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");
-		}
-
+		const selectedDevice = await selectIOSDevice(devices, options);
 		console.log(chalk.blue(`\nSelected device: ${selectedDevice.name}`));
 
 		// Boot device if needed
@@ -488,54 +693,12 @@ async function runIOS(options: RunOptions, metroProcess: ChildProcess | null): P
 		// Build the app
 		console.log(chalk.blue("\nBuilding iOS app...\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 cleanBuildIfNeeded("ios", options.clean);
 
+		const args = buildIOSArgs(options, selectedDevice.name);
 		await runCommand("npx", args);
 
-		// If Metro is running, launch app via deep link to connect to bundler
-		if (metroProcess && !options.release) {
-			const scheme = getAppScheme(process.cwd());
-			if (scheme) {
-				const bundlerUrl = `http://localhost:${options.port}`;
-				console.log(chalk.blue("\nLaunching app with bundler connection..."));
-				try {
-					await launchAppWithBundler("ios", scheme, bundlerUrl, selectedDevice.udid);
-					console.log(chalk.green(`✓ App launched with bundler: ${bundlerUrl}`));
-				} catch (error) {
-					// Deep link launch failed, but app should still work
-					console.log(
-						chalk.yellow(`Note: Deep link launch skipped - ${error instanceof Error ? error.message : "unknown error"}`)
-					);
-				}
-			}
-		}
+		await launchWithBundlerIfNeeded("ios", metroProcess, options, selectedDevice.udid);
 	} catch (error) {
 		spinner.fail("Failed to detect iOS devices");
 		throw error;
@@ -555,65 +718,16 @@ async function runAndroid(options: RunOptions, metroProcess: ChildProcess | null
 		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,
-							},
-							metroProcess
-						);
-						return;
-					}
-				}
+			const handled = await handleNoDevicesWithAVDs(options, metroProcess);
+			if (handled) {
+				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);
-		}
+		const selectedDevice = await selectAndroidDevice(devices, options);
 
 		await launchAndroidApp(
 			selectedDevice,
@@ -642,50 +756,12 @@ async function launchAndroidApp(
 	console.log(chalk.blue(`\nSelected device: ${device.name} (${device.type})`));
 	console.log(chalk.blue("\nBuilding Android app...\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 cleanBuildIfNeeded("android", options.clean);
 
+	const args = buildAndroidArgs(device, options);
 	await runCommand("npx", args);
 
-	// If Metro is running, launch app via deep link to connect to bundler
-	if (metroProcess && !options.release) {
-		const scheme = getAppScheme(process.cwd());
-		if (scheme) {
-			// Android emulator uses 10.0.2.2 to reach host machine
-			const bundlerUrl =
-				device.type === "emulator" ? `http://10.0.2.2:${options.port}` : `http://localhost:${options.port}`;
-			console.log(chalk.blue("\nLaunching app with bundler connection..."));
-			try {
-				await launchAppWithBundler("android", scheme, bundlerUrl, device.id);
-				console.log(chalk.green(`✓ App launched with bundler: ${bundlerUrl}`));
-			} catch (error) {
-				// Deep link launch failed, but app should still work
-				console.log(
-					chalk.yellow(`Note: Deep link launch skipped - ${error instanceof Error ? error.message : "unknown error"}`)
-				);
-			}
-		}
-	}
+	await launchWithBundlerIfNeeded("android", metroProcess, options, device.id, device.type);
 }
 
 /**