feat(cli): add devclient command to download prebuilt artifacts (by @coolsoftwaretyler)

Author: coolsoftwaretyler

src/commands/devclient.ts

@@ -1,4 +1,6 @@
 import { GluegunToolbox } from "gluegun"
+import * as os from "os"
+import * as path from "path"
 
 import { p, heading, warning, startSpinner, stopSpinner, clearSpinners } from "../tools/pretty"
 
@@ -14,6 +16,8 @@ interface GitHubRelease {
 
 type BuildType = "ios-simulator" | "android-emulator" | "android-device"
 
+const isMac = process.platform === "darwin"
+
 module.exports = {
   description: "Download pre-built Expo development clients from GitHub releases",
   run: async function (toolbox: GluegunToolbox) {
@@ -48,6 +52,7 @@ module.exports = {
       currentRelease = JSON.parse(currentReleaseResponse)
     } catch (error) {
       // Release doesn't exist or invalid response
+      warning("Failed to parse GitHub release")
     }
 
     const hasAssets = currentRelease?.assets && currentRelease.assets.length > 0
@@ -70,6 +75,7 @@ module.exports = {
         return
       }
 
+      // In the first iteration of this command, we'll get them all, but eventually we may want to limit this to some reasonable number (maybe?)
       let allReleases: GitHubRelease[] = []
       try {
         allReleases = JSON.parse(allReleasesResponse)
@@ -175,7 +181,274 @@ module.exports = {
       process.exit(1)
     }
 
+    // Install and launch based on build type
+    if (buildType === "ios-simulator") {
+      await installAndLaunchIOS(toolbox, targetPath)
+    } else if (buildType === "android-emulator") {
+      await installAndLaunchAndroid(toolbox, targetPath)
+    } else {
+      // We don't support installing directly to an Android device yet, log a message about it.
+      p()
+      print.info(
+        "📱 For Android device builds, transfer the APK to your device and install manually.",
+      )
+      p()
+    }
+
     clearSpinners()
     process.exit(0)
   },
 }
+
+async function installAndLaunchIOS(toolbox: GluegunToolbox, tarPath: string) {
+  const { print, system, filesystem } = toolbox
+
+  if (!isMac) {
+    p()
+    warning("⚠️  iOS Simulator installation is only available on macOS")
+    p()
+    return
+  }
+
+  p()
+  startSpinner("Extracting iOS build...")
+
+  // Extract the .tar.gz file
+  const extractDir = path.join(os.tmpdir(), `ignite-ios-${Date.now()}`)
+  filesystem.dir(extractDir)
+
+  try {
+    await system.run(`tar -xzf "${tarPath}" -C "${extractDir}"`)
+    stopSpinner("Extracting iOS build...", "✅")
+  } catch (error) {
+    stopSpinner("Extracting iOS build...", "❌")
+    warning(`Failed to extract: ${error.message}`)
+    return
+  }
+
+  // Find the .app file
+  const files = filesystem.list(extractDir) || []
+  const appFile = files.find((f) => f.endsWith(".app"))
+
+  if (!appFile) {
+    warning("No .app file found in archive")
+    return
+  }
+
+  const appPath = path.join(extractDir, appFile)
+
+  // Get list of available simulators
+  startSpinner("Finding iOS Simulators...")
+  let simulatorList
+  try {
+    simulatorList = await system.run("xcrun simctl list devices available --json", { trim: true })
+    stopSpinner("Finding iOS Simulators...", "✅")
+  } catch (error) {
+    stopSpinner("Finding iOS Simulators...", "❌")
+    warning("Failed to list simulators. Make sure Xcode is installed.")
+    return
+  }
+
+  let devices
+  try {
+    const simData = JSON.parse(simulatorList)
+    devices = simData.devices
+  } catch (error) {
+    warning("Failed to parse simulator list")
+    return
+  }
+
+  // Find a booted simulator or boot one
+  let bootedDevice: { udid: string; name: string } | null = null
+
+  for (const runtime in devices) {
+    const runtimeDevices = devices[runtime]
+    const booted = runtimeDevices.find((d: any) => d.state === "Booted")
+    if (booted) {
+      bootedDevice = { udid: booted.udid, name: booted.name }
+      break
+    }
+  }
+
+  // If no booted simulator, boot the first available one
+  if (!bootedDevice) {
+    p()
+    startSpinner("Booting iOS Simulator...")
+
+    // Find first available iOS (not watchOS or tvOS) simulator
+    let firstDevice: { udid: string; name: string; runtime: string } | null = null
+    for (const runtime in devices) {
+      if (runtime.includes("iOS") && !runtime.includes("watch")) {
+        const runtimeDevices = devices[runtime]
+        if (runtimeDevices.length > 0 && runtimeDevices[0].isAvailable !== false) {
+          firstDevice = {
+            udid: runtimeDevices[0].udid,
+            name: runtimeDevices[0].name,
+            runtime,
+          }
+          break
+        }
+      }
+    }
+
+    if (!firstDevice) {
+      stopSpinner("Booting iOS Simulator...", "❌")
+      warning("No available iOS simulators found")
+      return
+    }
+
+    try {
+      await system.run(`xcrun simctl boot ${firstDevice.udid}`)
+      // Open Simulator.app
+      await system.run("open -a Simulator")
+      stopSpinner("Booting iOS Simulator...", "✅")
+      bootedDevice = { udid: firstDevice.udid, name: firstDevice.name }
+      // Wait a bit for simulator to fully boot
+      await new Promise((resolve) => setTimeout(resolve, 3000))
+    } catch (error) {
+      stopSpinner("Booting iOS Simulator...", "❌")
+      warning(`Failed to boot simulator: ${error.message}`)
+      return
+    }
+  }
+
+  // Install app on the booted simulator
+  p()
+  startSpinner(`Installing on ${bootedDevice.name}...`)
+  try {
+    await system.run(`xcrun simctl install ${bootedDevice.udid} "${appPath}"`)
+    stopSpinner(`Installing on ${bootedDevice.name}...`, "✅")
+  } catch (error) {
+    stopSpinner(`Installing on ${bootedDevice.name}...`, "❌")
+    warning(`Failed to install: ${error.message}`)
+    return
+  }
+
+  // Get bundle ID from the app
+  startSpinner("Launching app...")
+  try {
+    const infoPlistPath = path.join(appPath, "Info.plist")
+    const bundleIdOutput = await system.run(
+      `/usr/libexec/PlistBuddy -c "Print CFBundleIdentifier" "${infoPlistPath}"`,
+      { trim: true },
+    )
+    const bundleId = bundleIdOutput.trim()
+
+    await system.run(`xcrun simctl launch ${bootedDevice.udid} ${bundleId}`)
+    stopSpinner("Launching app...", "✅")
+
+    p()
+    print.success(`🚀 App launched on ${bootedDevice.name}`)
+    p()
+  } catch (error) {
+    stopSpinner("Launching app...", "❌")
+    warning(`App installed but failed to launch: ${error.message}`)
+    p()
+  }
+
+  // Cleanup
+  filesystem.remove(extractDir)
+}
+
+async function installAndLaunchAndroid(toolbox: GluegunToolbox, apkPath: string) {
+  const { print, system } = toolbox
+
+  // Check if adb is available
+  startSpinner("Checking for Android SDK...")
+  try {
+    await system.run("adb version")
+    stopSpinner("Checking for Android SDK...", "✅")
+  } catch (error) {
+    stopSpinner("Checking for Android SDK...", "❌")
+    warning("adb not found. Make sure Android SDK is installed and in your PATH.")
+    p()
+    return
+  }
+
+  // Get list of devices/emulators
+  startSpinner("Finding Android devices...")
+  let deviceList
+  try {
+    deviceList = await system.run("adb devices", { trim: true })
+    stopSpinner("Finding Android devices...", "✅")
+  } catch (error) {
+    stopSpinner("Finding Android devices...", "❌")
+    warning("Failed to list devices")
+    return
+  }
+
+  const lines = deviceList.split("\n").slice(1) // Skip header
+  const devices = lines
+    .filter((line) => line.trim() && line.includes("device"))
+    .map((line) => line.split("\t")[0])
+
+  if (devices.length === 0) {
+    p()
+    warning("⚠️  No Android emulators or devices found running.")
+    print.info("Please start an Android emulator and run this command again.")
+    p()
+    return
+  }
+
+  // Use first device (or could prompt user to select)
+  const device = devices[0]
+  const isEmulator = device.startsWith("emulator-")
+
+  p()
+  startSpinner(`Installing on ${isEmulator ? "emulator" : "device"} ${device}...`)
+
+  try {
+    await system.run(`adb -s ${device} install -r "${apkPath}"`)
+    stopSpinner(`Installing on ${isEmulator ? "emulator" : "device"} ${device}...`, "✅")
+  } catch (error) {
+    stopSpinner(`Installing on ${isEmulator ? "emulator" : "device"} ${device}...`, "❌")
+    warning(`Failed to install: ${error.message}`)
+    return
+  }
+
+  // Get package name and launch
+  startSpinner("Launching app...")
+  try {
+    // For Expo dev clients, we know the package name pattern
+    // Try to extract it from the APK filename first
+    path.basename(apkPath)
+
+    // Use adb to list packages and find the one we just installed
+    // This is more reliable than trying to parse the APK
+    const packagesOutput = await system.run(
+      `adb -s ${device} shell pm list packages -3 | grep -E "(expo|ignite)"`,
+      { trim: true },
+    )
+
+    const lines = packagesOutput.split("\n")
+    let packageName = null
+
+    // Look for expo.modules.devmenu or expo.modules.devclient or host.exp.exponent
+    for (const line of lines) {
+      const pkg = line.replace("package:", "").trim()
+      if (pkg.includes("host.exp.exponent") || pkg.includes("expo")) {
+        packageName = pkg
+        break
+      }
+    }
+
+    if (!packageName) {
+      // Fallback: try common Expo dev client package names
+      packageName = "host.exp.exponent"
+    }
+
+    // Launch the app - Expo dev client uses .MainActivity
+    await system.run(`adb -s ${device} shell monkey -p ${packageName} 1`)
+    stopSpinner("Launching app...", "✅")
+
+    p()
+    print.success(`🚀 App launched on ${isEmulator ? "emulator" : "device"}`)
+    p()
+  } catch (error) {
+    stopSpinner("Launching app...", "❌")
+    warning(`App installed but failed to launch: ${error.message}`)
+    p()
+    print.info("You can manually launch the app from your device.")
+    p()
+  }
+}