mirror of
https://github.com/stablyai/orca.git
synced 2026-10-31 00:57:45 +00:00
Neil
4b347681bc
Add `pnpm native ensure <ios|android>`, which installs a cached dev-client build keyed by the Expo fingerprint and only runs `expo run` on a miss. The cache lives in the user cache dir so every worktree shares it, and app.config.js registers it as Expo's buildCacheProvider so plain `expo run` reuses hits too. A report-only PR job flags fingerprint changes against the base in the step summary.
370 lines
12 KiB
JavaScript
370 lines
12 KiB
JavaScript
#!/usr/bin/env node
|
|
// Installs the Orca dev client, rebuilding only when the Expo fingerprint of its native inputs
|
|
// changed. Builds are cached per fingerprint in the user cache dir, so every worktree reuses them.
|
|
//
|
|
// node scripts/native-client.mjs ensure <ios|android> [--device <name|udid|serial>] [--rebuild]
|
|
// node scripts/native-client.mjs fingerprint [--project <dir>] [--out <file>]
|
|
// node scripts/native-client.mjs compare <base.json> <head.json> [--project <dir>] [--summary <file>]
|
|
import { execFile, spawn } from 'node:child_process'
|
|
import fs from 'node:fs'
|
|
import path from 'node:path'
|
|
import process from 'node:process'
|
|
import { promisify } from 'node:util'
|
|
import nativeBuildCache from './native-build-cache.cjs'
|
|
|
|
const execFileAsync = promisify(execFile)
|
|
const PLATFORMS = ['ios', 'android']
|
|
const STAMP_FILE = '.orca-native-fingerprint'
|
|
const USAGE = `Usage:
|
|
native-client.mjs ensure <ios|android> [--device <name|udid|serial>] [--rebuild]
|
|
native-client.mjs fingerprint [--project <dir>] [--out <file>]
|
|
native-client.mjs compare <base.json> <head.json> [--project <dir>] [--summary <file>]`
|
|
|
|
export function parseArgs(argv) {
|
|
const positional = []
|
|
const flags = {}
|
|
for (let i = 0; i < argv.length; i++) {
|
|
const arg = argv[i]
|
|
if (arg === '--rebuild' || arg === '--help' || arg === '-h') {
|
|
flags[arg.replace(/^-+/, '')] = true
|
|
} else if (arg.startsWith('--')) {
|
|
const value = argv[i + 1]
|
|
if (value === undefined || value.startsWith('--')) {
|
|
throw new Error(`${arg} needs a value`)
|
|
}
|
|
flags[arg.slice(2)] = value
|
|
i++
|
|
} else {
|
|
positional.push(arg)
|
|
}
|
|
}
|
|
return { command: positional[0], positional: positional.slice(1), flags }
|
|
}
|
|
|
|
function log(message) {
|
|
console.log(`[native] ${message}`)
|
|
}
|
|
|
|
function shortHash(hash) {
|
|
return hash.slice(0, 12)
|
|
}
|
|
|
|
function runInherited(command, args, options = {}) {
|
|
return new Promise((resolve, reject) => {
|
|
const child = spawn(command, args, {
|
|
stdio: 'inherit',
|
|
shell: process.platform === 'win32',
|
|
...options
|
|
})
|
|
child.on('error', reject)
|
|
child.on('exit', (code, signal) => {
|
|
if (code === 0) {
|
|
resolve()
|
|
} else {
|
|
reject(
|
|
new Error(`${path.basename(command)} ${args.join(' ')} exited with ${signal ?? code}`)
|
|
)
|
|
}
|
|
})
|
|
})
|
|
}
|
|
|
|
function readStamp(nativeDir) {
|
|
try {
|
|
return fs.readFileSync(path.join(nativeDir, STAMP_FILE), 'utf8').trim()
|
|
} catch {
|
|
return null
|
|
}
|
|
}
|
|
|
|
// --- iOS Simulator ---------------------------------------------------------------------------
|
|
|
|
export function pickIosSimulator(devicesJson, requested) {
|
|
const simulators = Object.entries(devicesJson.devices ?? {}).flatMap(([runtime, list]) =>
|
|
runtime.includes('iOS') ? list.filter((device) => device.isAvailable !== false) : []
|
|
)
|
|
if (requested) {
|
|
return (
|
|
simulators.find((device) => device.udid === requested) ??
|
|
simulators.find((device) => device.name === requested) ??
|
|
null
|
|
)
|
|
}
|
|
return simulators.find((device) => device.state === 'Booted') ?? null
|
|
}
|
|
|
|
async function installOnIosSimulator(appPath, requested) {
|
|
if (process.platform !== 'darwin') {
|
|
throw new Error('iOS Simulator installs require macOS and Xcode.')
|
|
}
|
|
const { stdout } = await execFileAsync(
|
|
'xcrun',
|
|
['simctl', 'list', 'devices', 'available', '-j'],
|
|
{
|
|
encoding: 'utf8',
|
|
maxBuffer: 16 * 1024 * 1024
|
|
}
|
|
)
|
|
const simulator = pickIosSimulator(JSON.parse(stdout), requested)
|
|
if (!simulator) {
|
|
throw new Error(
|
|
requested
|
|
? `No available iOS simulator named or with UDID "${requested}".`
|
|
: 'No booted iOS simulator. Boot one or pass --device <name|udid>.'
|
|
)
|
|
}
|
|
if (simulator.state !== 'Booted') {
|
|
// Boots headless; Simulator.app is not opened or focused.
|
|
log(`Booting ${simulator.name}`)
|
|
await execFileAsync('xcrun', ['simctl', 'boot', simulator.udid])
|
|
}
|
|
await execFileAsync('xcrun', ['simctl', 'install', simulator.udid, appPath])
|
|
return `${simulator.name} (${simulator.udid})`
|
|
}
|
|
|
|
// --- Android ---------------------------------------------------------------------------------
|
|
|
|
function adbPath() {
|
|
const sdk = process.env.ANDROID_HOME || process.env.ANDROID_SDK_ROOT
|
|
if (sdk) {
|
|
const candidate = path.join(
|
|
sdk,
|
|
'platform-tools',
|
|
process.platform === 'win32' ? 'adb.exe' : 'adb'
|
|
)
|
|
if (fs.existsSync(candidate)) {
|
|
return candidate
|
|
}
|
|
}
|
|
return 'adb'
|
|
}
|
|
|
|
export function parseAdbDevices(stdout) {
|
|
return stdout
|
|
.split(/\r?\n/)
|
|
.slice(1)
|
|
.map((line) => line.trim().split(/\s+/))
|
|
.filter(([serial, state]) => serial && state === 'device')
|
|
.map(([serial]) => serial)
|
|
}
|
|
|
|
async function resolveAndroidSerial(adb, requested) {
|
|
const { stdout } = await execFileAsync(adb, ['devices'], { encoding: 'utf8' })
|
|
const serials = parseAdbDevices(stdout)
|
|
if (requested) {
|
|
if (serials.includes(requested)) {
|
|
return requested
|
|
}
|
|
for (const serial of serials.filter((s) => s.startsWith('emulator-'))) {
|
|
const { stdout: avd } = await execFileAsync(adb, ['-s', serial, 'emu', 'avd', 'name'], {
|
|
encoding: 'utf8'
|
|
}).catch(() => ({ stdout: '' }))
|
|
if (avd.split(/\r?\n/)[0].trim() === requested) {
|
|
return serial
|
|
}
|
|
}
|
|
throw new Error(`No running Android device or emulator matches "${requested}".`)
|
|
}
|
|
if (process.env.ANDROID_SERIAL && serials.includes(process.env.ANDROID_SERIAL)) {
|
|
return process.env.ANDROID_SERIAL
|
|
}
|
|
if (serials.length === 1) {
|
|
return serials[0]
|
|
}
|
|
throw new Error(
|
|
serials.length === 0
|
|
? 'No running Android emulator or device. Start one first.'
|
|
: `Several Android devices are connected (${serials.join(', ')}); pass --device <serial|avd>.`
|
|
)
|
|
}
|
|
|
|
async function installOnAndroid(apkPath, requested) {
|
|
const adb = adbPath()
|
|
const serial = await resolveAndroidSerial(adb, requested)
|
|
// -d: a cached build may carry an older versionCode than the one installed.
|
|
await execFileAsync(adb, ['-s', serial, 'install', '-r', '-d', apkPath], { encoding: 'utf8' })
|
|
return serial
|
|
}
|
|
|
|
// --- Commands --------------------------------------------------------------------------------
|
|
|
|
async function ensure(mobileRoot, platform, flags) {
|
|
if (!PLATFORMS.includes(platform)) {
|
|
throw new Error(`ensure needs a platform: ios or android\n${USAGE}`)
|
|
}
|
|
const device = flags.device
|
|
const cacheDir = nativeBuildCache.resolveCacheDir()
|
|
log(`Computing the ${platform} native fingerprint...`)
|
|
const { hash } = await nativeBuildCache.createNativeFingerprint(mobileRoot, platform)
|
|
const key = nativeBuildCache.cacheEntryKey(
|
|
platform,
|
|
hash,
|
|
nativeBuildCache.buildVariant(platform)
|
|
)
|
|
|
|
const cached = flags.rebuild ? null : nativeBuildCache.findCachedBuild(cacheDir, key)
|
|
if (cached) {
|
|
log(`HIT ${platform} fingerprint ${shortHash(hash)}: installing the cached build`)
|
|
log(` ${cached}`)
|
|
try {
|
|
const target =
|
|
platform === 'ios'
|
|
? await installOnIosSimulator(cached, device)
|
|
: await installOnAndroid(cached, device)
|
|
log(`Installed on ${target}. No native rebuild needed.`)
|
|
log('Start Metro with: pnpm start --dev-client')
|
|
return
|
|
} catch (error) {
|
|
log(`Installing the cached build failed: ${error.message}`)
|
|
log('Falling back to a fresh build.')
|
|
}
|
|
} else {
|
|
log(
|
|
flags.rebuild
|
|
? `REBUILD ${platform} fingerprint ${shortHash(hash)} (--rebuild)`
|
|
: `MISS ${platform} fingerprint ${shortHash(hash)}: native inputs changed, building`
|
|
)
|
|
}
|
|
|
|
const { ensureMobileExpoCli, getMobileExpoExecutablePath } = await import('./mobile-expo-cli.mjs')
|
|
await ensureMobileExpoCli(mobileRoot)
|
|
const expo = getMobileExpoExecutablePath(mobileRoot)
|
|
|
|
// `expo run` only prebuilds when the native directory is missing, so a directory generated from
|
|
// older inputs would be built and cached under the new fingerprint.
|
|
const nativeDir = path.join(mobileRoot, platform)
|
|
if (readStamp(nativeDir) !== hash) {
|
|
if (fs.existsSync(nativeDir)) {
|
|
log(`Regenerating ${platform}/ (it was generated from different native inputs)`)
|
|
fs.rmSync(nativeDir, { recursive: true, force: true })
|
|
}
|
|
await runInherited(expo, ['prebuild', '--platform', platform, '--no-install'], {
|
|
cwd: mobileRoot
|
|
})
|
|
fs.writeFileSync(path.join(nativeDir, STAMP_FILE), `${hash}\n`)
|
|
}
|
|
|
|
await runInherited(
|
|
expo,
|
|
[`run:${platform}`, '--no-bundler', ...(device ? ['--device', device] : [])],
|
|
{
|
|
cwd: mobileRoot,
|
|
env: { ...process.env, [nativeBuildCache.CACHE_MODE_ENV]: 'store' }
|
|
}
|
|
)
|
|
|
|
const stored = nativeBuildCache.findCachedBuild(cacheDir, key)
|
|
if (stored) {
|
|
log(`Built, installed, and cached ${platform} fingerprint ${shortHash(hash)}`)
|
|
log(` ${stored}`)
|
|
} else {
|
|
log(
|
|
platform === 'ios'
|
|
? 'Built and installed, but not cached: Expo caches iOS Simulator builds only.'
|
|
: 'Built and installed, but the build was not cached.'
|
|
)
|
|
}
|
|
log('Start Metro with: pnpm start --dev-client')
|
|
}
|
|
|
|
async function fingerprint(mobileRoot, flags) {
|
|
const result = {}
|
|
for (const platform of PLATFORMS) {
|
|
result[platform] = await nativeBuildCache.createNativeFingerprint(mobileRoot, platform)
|
|
log(`${platform} ${result[platform].hash}`)
|
|
}
|
|
if (flags.out) {
|
|
fs.writeFileSync(flags.out, JSON.stringify(result))
|
|
}
|
|
}
|
|
|
|
function describeSource(source) {
|
|
return source.type === 'contents' ? source.id : `${source.type} ${source.filePath}`
|
|
}
|
|
|
|
export function describeDiffItem(item) {
|
|
if (item.op === 'added') {
|
|
return `added ${describeSource(item.addedSource)}`
|
|
}
|
|
if (item.op === 'removed') {
|
|
return `removed ${describeSource(item.removedSource)}`
|
|
}
|
|
return `changed ${describeSource(item.afterSource)}`
|
|
}
|
|
|
|
const MAX_LISTED_SOURCES = 25
|
|
|
|
async function compare(mobileRoot, [basePath, headPath], flags) {
|
|
if (!basePath || !headPath) {
|
|
throw new Error(`compare needs two fingerprint files\n${USAGE}`)
|
|
}
|
|
const base = JSON.parse(fs.readFileSync(basePath, 'utf8'))
|
|
const head = JSON.parse(fs.readFileSync(headPath, 'utf8'))
|
|
const { diffFingerprints } = nativeBuildCache.loadFingerprintModule(mobileRoot)
|
|
const changedPlatforms = PLATFORMS.filter(
|
|
(platform) => base[platform]?.hash !== head[platform]?.hash
|
|
)
|
|
|
|
const lines = ['## Mobile native fingerprint', '']
|
|
if (changedPlatforms.length === 0) {
|
|
lines.push('Unchanged: existing dev-client builds still work with this PR.')
|
|
} else {
|
|
lines.push(
|
|
`**Changed for ${changedPlatforms.join(' and ')}.** Dev clients need a native rebuild ` +
|
|
'(`pnpm native ensure <ios|android>`).'
|
|
)
|
|
}
|
|
lines.push('', '| Platform | Base | Head |', '| --- | --- | --- |')
|
|
for (const platform of PLATFORMS) {
|
|
lines.push(
|
|
`| ${platform} | \`${shortHash(base[platform]?.hash ?? 'none')}\` | \`${shortHash(head[platform]?.hash ?? 'none')}\` |`
|
|
)
|
|
}
|
|
for (const platform of changedPlatforms) {
|
|
const items = diffFingerprints(base[platform], head[platform]).map(describeDiffItem)
|
|
lines.push('', `<details><summary>${platform}: ${items.length} changed sources</summary>`, '')
|
|
for (const item of items.slice(0, MAX_LISTED_SOURCES)) {
|
|
lines.push(`- ${item}`)
|
|
}
|
|
if (items.length > MAX_LISTED_SOURCES) {
|
|
lines.push(`- ...and ${items.length - MAX_LISTED_SOURCES} more`)
|
|
}
|
|
lines.push('', '</details>')
|
|
}
|
|
const markdown = `${lines.join('\n')}\n`
|
|
console.log(markdown)
|
|
if (flags.summary) {
|
|
fs.appendFileSync(flags.summary, markdown)
|
|
}
|
|
if (changedPlatforms.length > 0 && process.env.GITHUB_ACTIONS) {
|
|
console.log(
|
|
`::warning title=Mobile native fingerprint changed::This PR changes native inputs for ${changedPlatforms.join(' and ')}; dev clients need a native rebuild.`
|
|
)
|
|
}
|
|
}
|
|
|
|
async function main() {
|
|
const { command, positional, flags } = parseArgs(process.argv.slice(2))
|
|
if (!command || flags.help || flags.h) {
|
|
console.log(USAGE)
|
|
return
|
|
}
|
|
const mobileRoot = path.resolve(flags.project ?? path.join(import.meta.dirname, '..'))
|
|
if (command === 'ensure') {
|
|
await ensure(mobileRoot, positional[0], flags)
|
|
} else if (command === 'fingerprint') {
|
|
await fingerprint(mobileRoot, flags)
|
|
} else if (command === 'compare') {
|
|
await compare(mobileRoot, positional, flags)
|
|
} else {
|
|
throw new Error(`Unknown command "${command}"\n${USAGE}`)
|
|
}
|
|
}
|
|
|
|
if (process.argv[1] && path.resolve(process.argv[1]) === import.meta.filename) {
|
|
main().catch((error) => {
|
|
console.error(`[native] ${error.message}`)
|
|
process.exit(1)
|
|
})
|
|
}
|