bleam 0.0.7 → 0.0.9

package/templates/native/scripts/start/index.ts

@@ -0,0 +1,474 @@
+#!/usr/bin/env node
+
+import { type ChildProcess, execFileSync, spawn } from 'node:child_process'
+import {
+  copyFileSync,
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  renameSync,
+  rmSync,
+  writeFileSync,
+} from 'node:fs'
+import http from 'node:http'
+import path from 'node:path'
+import { ensureMLXSwiftCatalystFrameworks } from '../build/mlx-frameworks.ts'
+import { getKnownFailureGuidance } from './known-failures.ts'
+import { Loader } from './loader.ts'
+import {
+  clearNativeState,
+  computeNativeFingerprint,
+  getNativeChangeKind,
+  writeNativeState,
+} from './native-state.ts'
+import {
+  extractPackageProgressLabel,
+  getSwiftPackageResolvePlan,
+  type ResolvePackagesPlan,
+} from './swift-packages.ts'
+import { XcFormatter } from './xcode-formatter.ts'
+
+const XCODEBUILD_LOG_PATH = path.resolve(process.cwd(), 'build/xcodebuild.log')
+const SUCCESS_MARKER_PATH = path.resolve(
+  process.cwd(),
+  'build/.bleam-build-succeeded',
+)
+const XCODEBUILD_PROVISIONING_ARGS = [
+  '-allowProvisioningUpdates',
+  '-allowProvisioningDeviceRegistration',
+]
+
+class ReportedCommandError extends Error {
+  reported = true
+}
+
+function ensureVendoredPodSources() {
+  const nodeModules = path.resolve(process.cwd(), 'node_modules')
+  const restoredFiles: string[] = []
+
+  const sqliteIos = path.join(nodeModules, 'expo-sqlite', 'ios')
+  const sqliteVendor = path.join(
+    nodeModules,
+    'expo-sqlite',
+    'vendor',
+    'sqlite3',
+  )
+
+  if (existsSync(sqliteVendor)) {
+    for (const file of ['sqlite3.h', 'sqlite3.c']) {
+      const dest = path.join(sqliteIos, file)
+      const src = path.join(sqliteVendor, file)
+      if (!existsSync(dest) && existsSync(src)) {
+        copyFileSync(src, dest)
+        restoredFiles.push(`expo-sqlite/ios/${file}`)
+      }
+    }
+  }
+
+  if (restoredFiles.length > 0) {
+    console.log(
+      `\x1b[33m▸ Restored ${restoredFiles.length} missing pod source${restoredFiles.length === 1 ? '' : 's'}\x1b[0m`,
+    )
+  }
+}
+
+function findXcodeProj(dir: string): string | null {
+  try {
+    const files = readdirSync(dir)
+    const xcodeproj = files.find((file) => file.endsWith('.xcodeproj'))
+    return xcodeproj ? xcodeproj.replace('.xcodeproj', '') : null
+  } catch {
+    return null
+  }
+}
+
+function getProjectName(): string {
+  const iosDir = path.resolve(process.cwd(), 'ios')
+  const name = findXcodeProj(iosDir)
+
+  if (!name) {
+    throw new Error(
+      'Could not find .xcodeproj in ios/. Bleam.app must be a bare iOS project.',
+    )
+  }
+
+  return name
+}
+
+function parseArgs(argv: string[]): { clean: boolean; port: number } {
+  const clean = argv.includes('--clean') || argv.includes('-c')
+  const portFlagIndex = argv.findIndex(
+    (arg) => arg === '--port' || arg === '-p',
+  )
+  const inlinePort = argv
+    .find((arg) => arg.startsWith('--port='))
+    ?.split('=')[1]
+  const portValue =
+    inlinePort ?? (portFlagIndex === -1 ? undefined : argv[portFlagIndex + 1])
+  const port = portValue ? Number(portValue) : 8081
+
+  if (!Number.isInteger(port) || port <= 0) {
+    throw new Error(`Invalid port: ${portValue}`)
+  }
+
+  return { clean, port }
+}
+
+async function runXcodebuild(
+  args: string[],
+  label: string,
+  loader?: Loader,
+  onLine?: (line: string) => void,
+): Promise<void> {
+  const output: string[] = []
+  const formatter = new XcFormatter()
+  let loaderStopped = false
+  let pendingStdout = ''
+  let pendingStderr = ''
+
+  const emitLines = (chunk: string, pending: string): string => {
+    const text = pending + chunk
+    const lines = text.split(/\r?\n/)
+    const nextPending = lines.pop() ?? ''
+    for (const line of lines) {
+      onLine?.(line.trimEnd())
+    }
+    return nextPending
+  }
+
+  const stopLoader = () => {
+    if (loader && !loaderStopped) {
+      loader.stop()
+      loaderStopped = true
+    }
+  }
+
+  await new Promise<void>((resolve, reject) => {
+    const child = spawn('xcodebuild', args, {
+      cwd: process.cwd(),
+      env: process.env,
+    })
+
+    child.stdout.on('data', (chunk: Buffer) => {
+      const text = chunk.toString()
+      output.push(text)
+      formatter.write(text)
+      pendingStdout = emitLines(text, pendingStdout)
+    })
+
+    child.stderr.on('data', (chunk: Buffer) => {
+      const text = chunk.toString()
+      output.push(text)
+      formatter.write(text)
+      pendingStderr = emitLines(text, pendingStderr)
+    })
+
+    child.on('error', reject)
+    child.on('close', (code) => {
+      if (pendingStdout) {
+        onLine?.(pendingStdout.trimEnd())
+      }
+      if (pendingStderr) {
+        onLine?.(pendingStderr.trimEnd())
+      }
+      formatter.finish()
+      stopLoader()
+      if (code === 0) {
+        resolve()
+        return
+      }
+
+      reject(new Error(`${label} failed`))
+    })
+  }).catch((error) => {
+    stopLoader()
+    const fullOutput = output.join('')
+    mkdirSync(path.dirname(XCODEBUILD_LOG_PATH), { recursive: true })
+    writeFileSync(XCODEBUILD_LOG_PATH, fullOutput, 'utf8')
+
+    const summary = formatter.getFailureSummary()
+    const fallbackSummary = fullOutput.split(/\r?\n/).filter(Boolean).slice(-80)
+    console.error(`\n\x1b[31m✖ ${label} failed\x1b[0m\n`)
+    if (summary.length > 0) {
+      console.error(summary.join('\n'))
+      console.error('')
+    } else if (fallbackSummary.length > 0) {
+      console.error(fallbackSummary.join('\n'))
+      console.error('')
+    }
+    const guidance = getKnownFailureGuidance(fullOutput)
+    if (guidance.length > 0) {
+      console.error(guidance.join('\n'))
+    }
+    console.error(
+      `Full log: ${path.relative(process.cwd(), XCODEBUILD_LOG_PATH)}`,
+    )
+
+    const reportedError = new ReportedCommandError(
+      error instanceof Error ? error.message : String(error),
+    )
+    throw reportedError
+  })
+
+  mkdirSync(path.dirname(XCODEBUILD_LOG_PATH), { recursive: true })
+  writeFileSync(XCODEBUILD_LOG_PATH, output.join(''), 'utf8')
+}
+
+function clearBuildSuccessMarker() {
+  rmSync(SUCCESS_MARKER_PATH, { force: true })
+}
+
+function writeBuildSuccessMarker() {
+  mkdirSync(path.dirname(SUCCESS_MARKER_PATH), { recursive: true })
+  writeFileSync(SUCCESS_MARKER_PATH, `${Date.now()}\n`, 'utf8')
+}
+
+function hasSuccessfulBuild(appPath: string): boolean {
+  return existsSync(appPath) && existsSync(SUCCESS_MARKER_PATH)
+}
+
+function clearBuildReuseState() {
+  clearBuildSuccessMarker()
+  clearNativeState(process.cwd())
+}
+
+function removeBuildPath(target: string) {
+  if (!existsSync(target)) {
+    return
+  }
+
+  const tombstone = `${target}.deleting-${Date.now()}`
+  try {
+    renameSync(target, tombstone)
+    rmSync(tombstone, {
+      recursive: true,
+      force: true,
+      maxRetries: 10,
+      retryDelay: 100,
+    })
+  } catch {
+    rmSync(target, {
+      recursive: true,
+      force: true,
+      maxRetries: 10,
+      retryDelay: 100,
+    })
+  }
+}
+
+function waitForMetro(
+  port: number = 8081,
+  timeoutMs: number = 120_000,
+  intervalMs: number = 500,
+): Promise<void> {
+  return new Promise((resolve, reject) => {
+    const start = Date.now()
+
+    const poll = () => {
+      const req = http.get(`http://localhost:${port}/status`, (res) => {
+        let data = ''
+        res.on('data', (chunk: Buffer) => (data += chunk.toString()))
+        res.on('end', () => {
+          if (data.includes('packager-status:running')) {
+            resolve()
+          } else {
+            scheduleRetry()
+          }
+        })
+      })
+
+      req.on('error', () => {
+        scheduleRetry()
+      })
+
+      req.setTimeout(2000, () => {
+        req.destroy()
+        scheduleRetry()
+      })
+    }
+
+    const scheduleRetry = () => {
+      if (Date.now() - start > timeoutMs) {
+        reject(new Error(`Metro did not start within ${timeoutMs / 1000}s`))
+        return
+      }
+      setTimeout(poll, intervalMs)
+    }
+
+    poll()
+  })
+}
+
+async function buildApp(
+  projectName: string,
+  resolvePlan: ResolvePackagesPlan,
+): Promise<void> {
+  clearBuildReuseState()
+
+  const resolveLoader = new Loader('Resolving package dependencies')
+  resolveLoader.start()
+  await runXcodebuild(
+    [
+      ...XCODEBUILD_PROVISIONING_ARGS,
+      '-workspace',
+      `ios/${projectName}.xcworkspace`,
+      '-scheme',
+      projectName,
+      '-resolvePackageDependencies',
+      ...resolvePlan.args,
+      '-clonedSourcePackagesDirPath',
+      'build/SourcePackages',
+    ],
+    'Resolving package dependencies',
+    resolveLoader,
+    (line) => {
+      const packageLabel = extractPackageProgressLabel(line)
+      if (packageLabel) {
+        resolveLoader.update(`Resolving package dependencies - ${packageLabel}`)
+      }
+    },
+  )
+
+  const buildLoader = new Loader('Building for Mac Catalyst')
+  buildLoader.start()
+  await runXcodebuild(
+    [
+      ...XCODEBUILD_PROVISIONING_ARGS,
+      '-workspace',
+      `ios/${projectName}.xcworkspace`,
+      '-scheme',
+      projectName,
+      '-configuration',
+      'Debug',
+      '-destination',
+      'platform=macOS,arch=arm64,variant=Mac Catalyst',
+      '-derivedDataPath',
+      'build',
+      '-clonedSourcePackagesDirPath',
+      'build/SourcePackages',
+      'build',
+    ],
+    'Build',
+    buildLoader,
+  )
+
+  writeBuildSuccessMarker()
+  writeNativeState(process.cwd(), computeNativeFingerprint(process.cwd()))
+  console.log('\n\x1b[32m✔ Build complete\x1b[0m\n')
+}
+
+function startMetro(port: number): ChildProcess {
+  return spawn(
+    'npx',
+    ['expo', 'start', '--localhost', '--port', String(port)],
+    {
+      stdio: 'inherit',
+      shell: true,
+    },
+  )
+}
+
+function setupCleanup(metro: ChildProcess) {
+  const cleanup = (signal: NodeJS.Signals) => {
+    metro.kill(signal)
+    process.exit(0)
+  }
+
+  process.on('SIGINT', () => cleanup('SIGINT'))
+  process.on('SIGTERM', () => cleanup('SIGTERM'))
+
+  metro.on('exit', (code) => {
+    process.exit(code ?? 0)
+  })
+}
+
+function handleNativeChanges(clean: boolean) {
+  if (clean && existsSync('./build')) {
+    console.log('\x1b[33m▸ Cleaning build directory...\x1b[0m')
+    removeBuildPath('./build')
+    clearBuildReuseState()
+    return
+  }
+
+  if (clean) {
+    clearBuildReuseState()
+    return
+  }
+
+  const changeKind = getNativeChangeKind(process.cwd())
+  if (changeKind === 'structural') {
+    console.log(
+      '\x1b[33m▸ iOS native config changed since last build - removing stale build/Build\x1b[0m',
+    )
+    removeBuildPath('./build/Build')
+    clearBuildReuseState()
+  } else if (changeKind === 'incremental') {
+    console.log(
+      '\x1b[33m▸ iOS sources changed since last build - rebuilding app\x1b[0m',
+    )
+    clearBuildReuseState()
+  }
+}
+
+export async function startBleam(
+  argv: string[] = process.argv.slice(2),
+): Promise<void> {
+  const { clean, port } = parseArgs(argv)
+  const projectName = getProjectName()
+  const appPath = `./build/Build/Products/Debug-maccatalyst/${projectName}.app`
+
+  ensureVendoredPodSources()
+  handleNativeChanges(clean)
+
+  const needsBuild = clean || !hasSuccessfulBuild(appPath)
+
+  if (needsBuild) {
+    console.log('\x1b[36m▸ Preparing MLX Swift Catalyst frameworks...\x1b[0m')
+    ensureMLXSwiftCatalystFrameworks(process.cwd())
+    const resolvePlan = getSwiftPackageResolvePlan(process.cwd(), projectName)
+    if (resolvePlan.reason === 'resolved-remote-packages') {
+      console.log(
+        '\x1b[36m▸ Reusing resolved remote package pins from Package.resolved\x1b[0m',
+      )
+    }
+    await buildApp(projectName, resolvePlan)
+  } else {
+    console.log('\x1b[32m▸ Using existing build\x1b[0m')
+  }
+
+  const metroLoader = new Loader('Starting Metro')
+  metroLoader.start()
+  const metro = startMetro(port)
+  metroLoader.stop()
+  setupCleanup(metro)
+
+  const waitLoader = new Loader('Waiting for Metro')
+  waitLoader.start()
+  try {
+    await waitForMetro(port)
+    waitLoader.stop()
+    console.log('\n\x1b[36m▸ Opening app...\x1b[0m\n')
+    const bundleURL = `http://127.0.0.1:${port}/index.bundle?platform=ios&dev=true&minify=false`
+    execFileSync('open', [appPath, '--args', '--bleam-bundle-url', bundleURL], {
+      stdio: 'inherit',
+    })
+  } catch (err) {
+    waitLoader.fail()
+    console.error(
+      `\n\x1b[31m✖ ${err instanceof Error ? err.message : err}\x1b[0m`,
+    )
+  }
+}
+
+export function isReportedCommandError(error: unknown): boolean {
+  return error instanceof ReportedCommandError && error.reported
+}
+
+startBleam().catch((error) => {
+  if (isReportedCommandError(error)) {
+    process.exit(1)
+  }
+
+  console.error(error instanceof Error ? error.message : error)
+  process.exit(1)
+})

package/templates/native/scripts/start/known-failures.ts

@@ -0,0 +1,20 @@
+const FMT_CATALYST_FAILURE_PATTERNS = [
+  /Pods\/fmt\/include\/fmt\/format-inl\.h/i,
+  /call to consteval function/i,
+  /FMT_STRING\(/i,
+]
+
+export function isFmtCatalystFailure(output: string): boolean {
+  return FMT_CATALYST_FAILURE_PATTERNS.every((pattern) => pattern.test(output))
+}
+
+export function getKnownFailureGuidance(output: string): string[] {
+  if (!isFmtCatalystFailure(output)) {
+    return []
+  }
+
+  return [
+    '\n\x1b[33m▸ Detected the React Native/fmt Mac Catalyst compile failure.\x1b[0m',
+    "\x1b[33m  Re-run `pod install` so Bleam's Catalyst fmt and gnu++17 pod workarounds are applied before you run `yarn start` again.\x1b[0m",
+  ]
+}

package/templates/native/scripts/start/loader.ts

@@ -0,0 +1,76 @@
+const FRAMES = ['|', '/', '-', '\\']
+const CLEAR_LINE = '\r\x1b[2K'
+
+export class Loader {
+  #frameIndex: number = 0
+
+  #timer: ReturnType<typeof setInterval> | null = null
+
+  #started: boolean = false
+
+  #currentMessage: string
+
+  #message: string
+
+  #output: NodeJS.WriteStream
+
+  constructor(message: string, output: NodeJS.WriteStream = process.stdout) {
+    this.#message = message
+    this.#output = output
+    this.#currentMessage = message
+  }
+
+  start() {
+    if (this.#started) {
+      return
+    }
+
+    this.#started = true
+
+    if (!this.#output.isTTY) {
+      this.#output.write(`▸ ${this.#message}...\n`)
+      return
+    }
+
+    this.#render()
+    this.#timer = setInterval(() => {
+      this.#frameIndex = (this.#frameIndex + 1) % FRAMES.length
+      this.#render()
+    }, 100)
+  }
+
+  stop() {
+    if (!this.#started) {
+      return
+    }
+
+    if (this.#timer) {
+      clearInterval(this.#timer)
+      this.#timer = null
+    }
+
+    if (this.#output.isTTY) {
+      this.#output.write(CLEAR_LINE)
+    }
+
+    this.#started = false
+  }
+
+  fail() {
+    this.stop()
+  }
+
+  update(message: string) {
+    this.#currentMessage = message
+
+    if (this.#started && this.#output.isTTY) {
+      this.#render()
+    }
+  }
+
+  #render() {
+    this.#output.write(
+      `${CLEAR_LINE}\x1b[36m${FRAMES[this.#frameIndex]} ${this.#currentMessage}...\x1b[0m`,
+    )
+  }
+}